/*

* Copyright (c) 2010 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: SecUi notification plugin class.

*

*/

#include "secuinotificationdebug.h"

#include "secuinotificationdialog.h"

#include "secuinotificationdialogpluginkeys.h"

#include "secuinotificationcontentwidget.h"

// #include <hbpopupbase.h>        // HbPopupBase::NoTimeout

#include <hblabel.h>

#include <hbaction.h>

#include <QDebug>

#include <e32debug.h>

#include <hbtranslator.h>

#include <cphcltemergencycall.h>

#include <SCPServerInterface.h>	// for TARM error codes while validating new lock code

#include <QString>

#include <QDialogButtonBox>

#include <HbEditorInterface>

#include <e32property.h>

QTM_USE_NAMESPACE

const QString KTranslationsPath = "/resource/qt/translations/";

const QString KSecUiNotificationTranslationsFile = "secui";

const QString KCommonTranslationsFile = "common";

#include <qvaluespacesubscriber.h>

#include <qvaluespacepublisher.h>

#define ESecUiBasicTypeText    0x0000000

#define ESecUiBasicTypeCheck   0x0010000

#define ESecUiBasicTypeCheckMulti   0x0020000

#define ESecUiBasicTypeMask    0x00F0000

#define ESecUiCancelSupported  0x1000000

#define ESecUiCancelNotSupported  0x0000000

#define ESecUiEmergencySupported  0x2000000

#define ESecUiEmergencyNotSupported  0x0000000

#define ESecUiAlphaSupported  0x4000000

#define ESecUiAlphaNotSupported  0x0000000

#define ESecUiSecretSupported  0x8000000

#define ESecUiSecretNotSupported  0x0000000

#define ESecUiMaskFlags  0xFF000000

#define ESecUiMaskType   0x00FFFFFF

#define ESecUiTypeDeviceLock		0x00100000

#define ESecUiTypeKeyguard			0x00200000

#define ESecUiTypeClock  				0x00300000

#define ESecUiTypeScreensaver		0x00400000

#define ESecUiTypeMaskLock			0x00F00000

const TUid KPSUidSecurityUIs = { 0x100059b5 };

const TUint32 KSecurityUIsDismissDialog  = 0x00000309;

enum TSecurityUIsDismissDialogValues

    {

    ESecurityUIsDismissDialogUninitialized = 0,

    ESecurityUIsDismissDialogOn,

    ESecurityUIsDismissDialogProcessing,

    ESecurityUIsDismissDialogDone,

    ESecurityUIsDismissDialogLastValue

    };

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::SecUiNotificationDialog()

// ----------------------------------------------------------------------------

//

SecUiNotificationDialog::SecUiNotificationDialog(

        const QVariantMap &parameters) : HbDialog(), mCommonTranslator(0), mSecUiNotificationTranslator(0), mLastError(KNoError)

{

		RDEBUG("0", 0);

		TTime myTime;

    myTime.HomeTime();

		mMyId = I64LOW( myTime.Int64() );

    mCommonTranslator = new HbTranslator(KTranslationsPath, KCommonTranslationsFile);

    mSecUiNotificationTranslator = new HbTranslator(KTranslationsPath, KSecUiNotificationTranslationsFile);

    constructDialog(parameters);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::~SecUiNotificationDialog()

// ----------------------------------------------------------------------------

//

SecUiNotificationDialog::~SecUiNotificationDialog()

{

		RDEBUG("0", 0);

    delete mSecUiNotificationTranslator;

    delete mCommonTranslator;

		RDEBUG("0", 0);

    // TODO what about subscriberKSecurityUIsDismissDialog

    // and codeTop

		RDEBUG("1", 1);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::setDeviceDialogParameters()

// ----------------------------------------------------------------------------

//

bool SecUiNotificationDialog::setDeviceDialogParameters(const QVariantMap &parameters)

{

	 RDEBUG("0", 0);

   return constructDialog(parameters);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::deviceDialogError()

// ----------------------------------------------------------------------------

//

int SecUiNotificationDialog::deviceDialogError() const

{

		RDEBUG("mLastError", mLastError);

		RDEBUG("mMyId", mMyId);

    return mLastError;

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::closeDeviceDialog

// ----------------------------------------------------------------------------

//

void SecUiNotificationDialog::closeDeviceDialog(bool byClient)

{

    Q_UNUSED(byClient);

		RDEBUG("mMyId", mMyId);

		RDEBUG("calling close()", 0);

    close();

		RDEBUG("mShowEventReceived", mShowEventReceived);

    // If show event has been received, close is signalled from hide event.

    // If not, hide event does not come and close is signalled from here.

    if (!mShowEventReceived) {

    		RDEBUG("emitting deviceDialogClosed", 0);

        emit deviceDialogClosed();

				if(1==0 && subscriberKSecurityUIsDismissDialog)

					{

						RDEBUG("disconnect subscriberKSecurityUIsDismissDialog", 0);

						disconnect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));

						RDEBUG("disconnected subscriberKSecurityUIsDismissDialog", 1);

						if(1==1)

							{

							RDEBUG("deleting subscriberKSecurityUIsDismissDialog", 0);

							delete subscriberKSecurityUIsDismissDialog;

							subscriberKSecurityUIsDismissDialog = NULL;

							RDEBUG("deleted subscriberKSecurityUIsDismissDialog", 1);

							}

				 }

    }

    RDEBUG("0", 0);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::deviceDialogWidget

// ----------------------------------------------------------------------------

//

HbDialog *SecUiNotificationDialog::deviceDialogWidget() const

{

    return const_cast<SecUiNotificationDialog*>(this);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::hideEvent

// ----------------------------------------------------------------------------

//

void SecUiNotificationDialog::hideEvent(QHideEvent *event)

{

		RDEBUG("0", 0);

    HbDialog::hideEvent(event);

		RDEBUG("mMyId", mMyId);

		RDEBUG("calling close()", 0);

		close();

		RDEBUG("emitting deviceDialogClosed", 0);

		emit deviceDialogClosed();

		RDEBUG("deviceDialogClosed", 1);

		if(1==0 && subscriberKSecurityUIsDismissDialog)

			{

				RDEBUG("disconnect subscriberKSecurityUIsDismissDialog", 0);

				disconnect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));

				RDEBUG("disconnected subscriberKSecurityUIsDismissDialog", 1);

				if(1==1)

					{ 

					RDEBUG("deleting subscriberKSecurityUIsDismissDialog", 0);

					delete subscriberKSecurityUIsDismissDialog;

					subscriberKSecurityUIsDismissDialog = NULL;

					RDEBUG("deleted subscriberKSecurityUIsDismissDialog", 1);

					}

			}

    // old method was   emit deviceDialogClosed();

   RDEBUG("0", 0);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::showEvent

// ----------------------------------------------------------------------------

//

void SecUiNotificationDialog::showEvent(QShowEvent *event)

{

		RDEBUG("0", 0);

		RDEBUG("mMyId", mMyId);

    HbDialog::showEvent(event);

		if(!(queryType & ESecUiTypeMaskLock))

			{	// not for the "lock icon"

			RDEBUG("check default.1", 0);

			if(codeTop!=NULL)

            {

            RDEBUG("check default.2", 0);

            if(codeTop->text().length()>0)	// there's a default value. Verify it and (might) enable OK

                {

                RDEBUG("check default.3", 0);

                handleCodeTopChanged(codeTop->text());

                }

            RDEBUG("setFocus", 0);

            }	// codeTop!=NULL

			const TUint32 KSecurityUIsTestCode  = 0x00000307;

			TInt value = 0;

			TInt err = RProperty::Get(KPSUidSecurityUIs, KSecurityUIsTestCode, value );

			RDEBUG("KSecurityUIsTestCode err", err);

			RDEBUG("faking value", value);

			RDEBUG("mShowEventReceived", mShowEventReceived);

			if(value>0 && value<1000000 && mShowEventReceived==true)	// show happens 2 times. Dialog can be closed only the second.

				{

				QString myString = "";

				myString += QString("%1").arg(value);

				RDEBUGQT("myString", myString);

		    codeTop->setText( myString );

		    TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsTestCode, 0 );	// clear after using it

		    RDEBUGQT("calling handleAccepted myString", myString);

		    emit handleAccepted();

				// handleAccepted already   emit closeDeviceDialog(false);	// false means "not by client", although it's not really used

				}

			}

    mShowEventReceived = true;

    RDEBUG("1", 1);

}

// ----------------------------------------------------------------------------

// SecUiNotificationDialog::constructDialog()

// ----------------------------------------------------------------------------

//

bool SecUiNotificationDialog::constructDialog(const QVariantMap &parameters)

    {

		RDEBUG("0", 0);

		RDEBUG("mMyId", mMyId);

    setTimeout(HbPopup::NoTimeout);

    setDismissPolicy(HbPopup::NoDismiss);

    setModal(true);

    mShowEventReceived = false;

    subscriberKSecurityUIsDismissDialog = NULL;

    titleWidget = NULL;

		RDEBUG("subscriberKSecurityUIsDismissDialog NULL", 0);

    subscriberKSecurityUIsDismissDialog = new QValueSpaceSubscriber("/KPSUidSecurityUIs/KSecurityUIsDismissDialog", this);

    if(subscriberKSecurityUIsDismissDialog)

    	{

    	RDEBUG("subscriberKSecurityUIsDismissDialog created", 1);

    	}

    else

    	{

    	RDEBUG("subscriberKSecurityUIsDismissDialog not created", 0);

    	}

    connect(subscriberKSecurityUIsDismissDialog, SIGNAL(contentsChanged()), this, SLOT(subscriberKSecurityUIsDismissDialogChanged()));

		RDEBUG("subscriberKSecurityUIsDismissDialog", 1);

    // Title

    // this is also done later in the widget

    // For now, it only says "Security"

    if (parameters.contains(KDialogTitle)) {

        QString titleText = parameters.value(KDialogTitle).toString();

        QString titleAttempts = "";

   			if(titleText.indexOf('|')>0)

    				{	// if separator, take only first part

    				titleText = titleText.left(titleText.indexOf('|'));

    				}

   			if(titleText.indexOf('$')>0)

    				{	// if separator, take only first part

    				titleAttempts = titleText.right(titleText.length()-titleText.indexOf('$')-1);

    				RDEBUGQT("titleAttempts", titleAttempts);

    				int nAttempts = titleAttempts.toInt();

    				RDEBUG("nAttempts", nAttempts);

    				titleText = titleText.left(titleText.indexOf('$'));

    				if(nAttempts>0)

    					titleText = titleText + " attempts=" + QString::number(nAttempts);

    				}

    		titleText = hbTrId("Security Query");	// this is the header, for any potential later error which needs to be displayed

        // This is created only if needed (i.e. errors for NewLockCode)

        // titleWidget = new HbLabel(titleText);

        // setHeadingWidget(titleWidget);

    }

	    if (parameters.contains(KEmergency)) {

					RDEBUG("KEmergency", 1);

	        QString emergencyText = parameters.value(KEmergency).toString();

	        RDEBUGQT("emergencyText", emergencyText);

	        if(!emergencyText.compare("emergencyYes"))

	        	{

	        	RDEBUG("emergencyYes", 1);

	        	isEmergency = 1;

	        	okAction->setEnabled(true);

	        	okAction->setText(hbTrId("Call"));

    				return true;

	        	}

	        if(!emergencyText.compare("emergencyNo"))

	        	{

	        	RDEBUG("emergencyNo", 1);

	        	isEmergency = 0;

	        	okAction->setEnabled(false);	// 112 -> 1122 (=password) . This is handled by   < lMinLength 

	        	okAction->setText(hbTrId("Ok"));

    				return true;

	        	}

	    }

	    // after TARM validation.

	    if (parameters.contains(KInvalidNewLockCode)) {

					RDEBUG("KInvalidNewLockCode", 0);

	        QString invalidText = parameters.value(KInvalidNewLockCode).toString();

	        RDEBUGQT("invalidText", invalidText);

	        QString newTitleText = "Lock Code";	// TODO take from the original one

	        QString invalidStr = invalidText.right(invalidText.length()-invalidText.indexOf('$')-1);

	        int invalidNumber = invalidStr.toInt();

	        RDEBUG("invalidNumber", invalidNumber);

	        if(invalidNumber<0)	// that is, -1

	        	{

	        	RDEBUG("invalidNumber<0", invalidNumber );

	        	// nothing to do

	        	}

				if(invalidNumber==EDeviceLockAutolockperiod)

	        	{

	        	RDEBUG("EDeviceLockAutolockperiod", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockAutolockperiod");

	        	}

	        if(invalidNumber==EDeviceLockMaxAutolockPeriod)

	        	{

	        	RDEBUG("EDeviceLockAutolockperiod", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMaxAutolockPeriod");

	        	}

	        if(invalidNumber==EDeviceLockMinlength)

	        	{

	        	RDEBUG("EDeviceLockMinlength", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMinlength");

	        	}

	        if(invalidNumber==EDeviceLockMaxlength)

	        	{

	        	RDEBUG("EDeviceLockMaxlength", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMaxlength");

	        	}

	        if(invalidNumber==EDeviceLockRequireUpperAndLower)

	        	{

	        	RDEBUG("EDeviceLockRequireUpperAndLower", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockRequireUpperAndLower");

	        	}

	        if(invalidNumber==EDeviceLockRequireCharsAndNumbers)

	        	{

	        	RDEBUG("EDeviceLockMaxlength", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMaxlength");

	        	}

	        if(invalidNumber==EDeviceLockAllowedMaxRepeatedChars)

	        	{

	        	RDEBUG("EDeviceLockAllowedMaxRepeatedChars", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockAllowedMaxRepeatedChars");

	        	}

	        if(invalidNumber==EDeviceLockHistoryBuffer)

	        	{

	        	RDEBUG("EDeviceLockHistoryBuffer", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockHistoryBuffer");

	        	}

	        if(invalidNumber==EDeviceLockPasscodeExpiration)

	        	{

	        	RDEBUG("EDeviceLockPasscodeExpiration", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockPasscodeExpiration");

	        	}

	        if(invalidNumber==EDeviceLockMinChangeTolerance)

	        	{

	        	RDEBUG("EDeviceLockMinChangeTolerance", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMinChangeTolerance");

	        	}

	        if(invalidNumber==EDeviceLockMinChangeInterval)

	        	{

	        	RDEBUG("EDeviceLockMinChangeInterval", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMinChangeInterval");

	        	}

	        if(invalidNumber==EDeviceLockDisallowSpecificStrings)

	        	{

	        	RDEBUG("EDeviceLockDisallowSpecificStrings", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockDisallowSpecificStrings");

	        	}

	        if(invalidNumber==EDeviceLockAllowedMaxAtempts)

	        	{

	        	RDEBUG("EDeviceLockAllowedMaxAtempts", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockAllowedMaxAtempts");

	        	}

	        if(invalidNumber==EDeviceLockConsecutiveNumbers)

	        	{

	        	RDEBUG("EDeviceLockConsecutiveNumbers", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockConsecutiveNumbers");

	        	}

	        if(invalidNumber==EDeviceLockMinSpecialCharacters)

	        	{

	        	RDEBUG("EDeviceLockMinSpecialCharacters", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockMinSpecialCharacters");

	        	}

	        if(invalidNumber==EDeviceLockSingleCharRepeatNotAllowed)

	        	{

	        	RDEBUG("EDeviceLockSingleCharRepeatNotAllowed", invalidNumber );

	        	newTitleText+=hbTrId("EDeviceLockSingleCharRepeatNotAllowed");

	        	}

	        if(invalidNumber==EDevicelockConsecutiveCharsNotAllowed)

	        	{

	        	RDEBUG("EDevicelockConsecutiveCharsNotAllowed", invalidNumber );

	        	newTitleText+=hbTrId("EDevicelockConsecutiveCharsNotAllowed");

	        	}

	        if(invalidNumber>=EDevicelockTotalPolicies)

	        	{

	        	RDEBUG("EDevicelockTotalPolicies", invalidNumber );

	        	newTitleText+=hbTrId("EDevicelockTotalPolicies");

	        	}

	        if( !titleWidget )

	        	{

	        	RDEBUG("creating titleWidget", 0 );

	        	titleWidget = new HbLabel(hbTrId("New lock code"));	// it will be changed later

          	setHeadingWidget(titleWidget);

          	}

          RDEBUG("setPlainText", 0 );

	        titleWidget->setPlainText(newTitleText);

	        if(invalidNumber<0)	// everything is ok

	        	{

	        	okAction->setEnabled(true);	// this might fail in the scenario: check this : invalid -> valid. This allows verif ?

	        	okAction->setText(hbTrId("Ok"));

	        	codeBottom->setEnabled(true);

	        	}

	        else

	        	{

	        	okAction->setEnabled(false);

	        	codeBottom->setEnabled(false);

	        	codeBottom->setText("");

	        	okAction->setText(hbTrId("Ok"));

	        	}

	        // need to return because all objects are already created

   				return true;

	    }

    // Content

    SecUiNotificationContentWidget *content = new SecUiNotificationContentWidget();

    content->constructFromParameters(parameters);

    setContentWidget(content);

		queryType = content->queryType;

		queryDual = content->queryDual;

		isEmergency = content->isEmergency;

    codeTop=NULL;

		codeTop = content->codeTop;

    checkBox = content->checkbox;

    listWidget = content->listWidget;

		codeBottom = content->codeBottom;

		lMinLength = content->lMinLength;

		lMaxLength = content->lMaxLength;

		lEmergencySupported = content->lEmergencySupported;

    connect(content, SIGNAL(codeTopChanged(const QString &)), this, SLOT(handleCodeTopChanged(const QString &)));

    connect(content, SIGNAL(codeBottomChanged(const QString &)), this, SLOT(handleCodeBottomChanged(const QString &)));

    connect(content, SIGNAL(codeTopContentChanged()), this, SLOT(handleCodeTopContentChanged()));

    connect(content, SIGNAL(but1Changed()), this, SLOT(handlebut1Changed()));

    connect(content, SIGNAL(but2Changed()), this, SLOT(handlebut2Changed()));

    connect(content, SIGNAL(but3Changed()), this, SLOT(handlebut3Changed()));

		RDEBUG("queryType", queryType);

    // Buttons

    if( (queryType & ESecUiTypeMaskLock))

    	{

    	// no need to create OK or Cancel

    	return true;

    	}