/*

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

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

#include <QString>

#include <QDialogButtonBox>

#include <e32property.h>

QTM_USE_NAMESPACE

#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(), mLastError(KNoError)

{

		RDEBUG("0", 0);

    constructDialog(parameters);

}

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

// SecUiNotificationDialog::~SecUiNotificationDialog()

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

//

SecUiNotificationDialog::~SecUiNotificationDialog()

{

}

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

// SecUiNotificationDialog::setDeviceDialogParameters()

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

//

bool SecUiNotificationDialog::setDeviceDialogParameters(const QVariantMap &parameters)

{

	 RDEBUG("0", 0);

   return constructDialog(parameters);

}

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

// SecUiNotificationDialog::deviceDialogError()

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

//

int SecUiNotificationDialog::deviceDialogError() const

{

		RDEBUG("mLastError", mLastError);

    return mLastError;

}

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

// SecUiNotificationDialog::closeDeviceDialog

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

//

void SecUiNotificationDialog::closeDeviceDialog(bool byClient)

{

    Q_UNUSED(byClient);

    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) {

        emit deviceDialogClosed();

    }

}

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

// SecUiNotificationDialog::deviceDialogWidget

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

//

HbDialog *SecUiNotificationDialog::deviceDialogWidget() const

{

    return const_cast<SecUiNotificationDialog*>(this);

}

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

// SecUiNotificationDialog::hideEvent

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

//

void SecUiNotificationDialog::hideEvent(QHideEvent *event)

{

		RDEBUG("0", 0);

    HbDialog::hideEvent(event);

		close();

		emit deviceDialogClosed();

		RDEBUG("deviceDialogClosed", 1);

    // old method was   emit deviceDialogClosed();

}

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

// SecUiNotificationDialog::showEvent

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

//

void SecUiNotificationDialog::showEvent(QShowEvent *event)

{

		RDEBUG("0", 0);

    HbDialog::showEvent(event);

		if(!(queryType & ESecUiTypeMaskLock))

			{	// not for the "lock icon"

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

			if(codeTop!=NULL)

            {

                {

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

                handleCodeTopChanged(codeTop->text());

                }

			const TUint32 KSecurityUIsTestCode  = 0x00000307;

			TInt value = 0;

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

			RDEBUG("KSecurityUIsTestCode err", err);

			RDEBUG("faking value", value);

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

				{

				QString myString = "";

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

				qDebug() << "SecUiNotificationDialog::faking myString=" << myString;

		    codeTop->setText( myString );

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

				qDebug() << "SecUiNotificationDialog::calling handleAccepted=" << myString;

		    emit handleAccepted();

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

				}

			}

    mShowEventReceived = true;

}

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

// SecUiNotificationDialog::constructDialog()

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

//

bool SecUiNotificationDialog::constructDialog(const QVariantMap &parameters)

    {

		RDEBUG("0", 0);

    setTimeout(HbPopup::NoTimeout);

    setDismissPolicy(HbPopup::NoDismiss);

    setModal(true);

    mShowEventReceived = false;

    // Title

    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);

    				qDebug() << "SecUiNotificationDialog::titleAttempts=" << titleAttempts;

    				int nAttempts = titleAttempts.toInt();

    				RDEBUG("nAttempts", nAttempts);

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

    				if(nAttempts>0)

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

    				}

    }

	    if (parameters.contains(KEmergency)) {

					RDEBUG("KEmergency", 1);

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

	        qDebug() << emergencyText;

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

	        	{

	        	RDEBUG("emergencyYes", 1);

	        	isEmergency = 1;

	        	okAction->setEnabled(true);

	        	okAction->setText("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("Ok");

    				return true;

	        	}

	    }

	    // after TARM validation.

	    if (parameters.contains(KInvalidNewLockCode)) {

					RDEBUG("KInvalidNewLockCode", 0);

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

	        qDebug() << invalidText;

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

	        int invalidNumber = invalidStr.toInt();

	        RDEBUG("invalidNumber", invalidNumber);

	        if(invalidNumber<0)

	        	{

	        	RDEBUG("invalidNumber<0", invalidNumber );

	        	// nothing to do

	        	}

				if(invalidNumber==EDeviceLockAutolockperiod)

	        	{

	        	RDEBUG("EDeviceLockAutolockperiod", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMaxAutolockPeriod)

	        	{

	        	RDEBUG("EDeviceLockAutolockperiod", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMinlength)

	        	{

	        	RDEBUG("EDeviceLockMinlength", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMaxlength)

	        	{

	        	RDEBUG("EDeviceLockMaxlength", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockRequireUpperAndLower)

	        	{

	        	RDEBUG("EDeviceLockRequireUpperAndLower", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockRequireCharsAndNumbers)

	        	{

	        	RDEBUG("EDeviceLockMaxlength", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockAllowedMaxRepeatedChars)

	        	{

	        	RDEBUG("EDeviceLockAllowedMaxRepeatedChars", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockHistoryBuffer)

	        	{

	        	RDEBUG("EDeviceLockHistoryBuffer", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockPasscodeExpiration)

	        	{

	        	RDEBUG("EDeviceLockPasscodeExpiration", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMinChangeTolerance)

	        	{

	        	RDEBUG("EDeviceLockMinChangeTolerance", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMinChangeInterval)

	        	{

	        	RDEBUG("EDeviceLockMinChangeInterval", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockDisallowSpecificStrings)

	        	{

	        	RDEBUG("EDeviceLockDisallowSpecificStrings", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockAllowedMaxAtempts)

	        	{

	        	RDEBUG("EDeviceLockAllowedMaxAtempts", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockConsecutiveNumbers)

	        	{

	        	RDEBUG("EDeviceLockConsecutiveNumbers", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockMinSpecialCharacters)

	        	{

	        	RDEBUG("EDeviceLockMinSpecialCharacters", invalidNumber );

	        	}

	        if(invalidNumber==EDeviceLockSingleCharRepeatNotAllowed)

	        	{

	        	RDEBUG("EDeviceLockSingleCharRepeatNotAllowed", invalidNumber );

	        	}

	        if(invalidNumber==EDevicelockConsecutiveCharsNotAllowed)

	        	{

	        	RDEBUG("EDevicelockConsecutiveCharsNotAllowed", invalidNumber );

	        	}

	        if(invalidNumber>=EDevicelockTotalPolicies)

	        	{

	        	RDEBUG("EDevicelockTotalPolicies", invalidNumber );

	        	}

	        if(invalidNumber<0)	// everything is ok

	        	{

	        	okAction->setText("Ok");

	        	codeBottom->setEnabled(true);

	        	}

	        else

	        	{

	        	okAction->setEnabled(false);

	        	codeBottom->setEnabled(false);

	        	codeBottom->setText("");

	        	okAction->setText("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;

    	}

    okAction = new HbAction(tr("Ok"));

    RDEBUG("created HbAction okAction", 1);

    okAction->setEnabled(false);	// initially the OK is disabled because codeTop is empty

    if((queryType & ESecUiBasicTypeMask) ==ESecUiBasicTypeCheck) {

        okAction->setEnabled(true);

        setHeadingWidget(0); // had to remove this no multiline

    }

    else if ((queryType & ESecUiBasicTypeMask) ==ESecUiBasicTypeCheckMulti){

        okAction->setEnabled(true);

    }

    // setAction(okAction, QDialogButtonBox::AcceptRole);	// it's supposed to use this, when deprecated

    // setPrimaryAction(okAction);

    addAction(okAction);