/*
* 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:  Device dialog plugin that shows untrusted certificate
*               dialog for TLS server authentication failure errors.
*
*/

#include "untrustedcertificatedialog.h"
#include "untrustedcertificatedefinitions.h"
#include "untrustedcertificatewidget.h"
#include <hblabel.h>
#include <hbaction.h>
#include <hbmessagebox.h>
#include <QGraphicsLinearLayout>

const int KNoError = 0;             // KErrNone
const int KParameterError = -6;     // KErrArgument

// TODO: replace with OST tracing
#ifdef _DEBUG
#include <QDebug>
#define TRACE(x)        qDebug() << x
#define TRACE1(x,y)     qDebug() << x << y
#else
#define TRACE(x)
#define TRACE1(x,y)
#endif


// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::UntrustedCertificateDialog()
// ----------------------------------------------------------------------------
//
UntrustedCertificateDialog::UntrustedCertificateDialog(const QVariantMap &parameters) :
    HbDialog(), mLastError(KNoError), mContent(0), mResultMap(),
    mShowEventReceived(false), mOkAction(0)
{
    constructDialog(parameters);
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::~UntrustedCertificateDialog()
// ----------------------------------------------------------------------------
//
UntrustedCertificateDialog::~UntrustedCertificateDialog()
{
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::setDeviceDialogParameters()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateDialog::setDeviceDialogParameters(const QVariantMap &parameters)
{
   return updateFromParameters(parameters);
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::deviceDialogError()
// ----------------------------------------------------------------------------
//
int UntrustedCertificateDialog::deviceDialogError() const
{
    return mLastError;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::closeDeviceDialog()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::closeDeviceDialog(bool byClient)
{
    Q_UNUSED(byClient);
    TRACE("UntrustedCertificateDialog::closeDeviceDialog");
    close();

    // 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();
    }
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::deviceDialogWidget()
// ----------------------------------------------------------------------------
//
HbDialog *UntrustedCertificateDialog::deviceDialogWidget() const
{
    return const_cast<UntrustedCertificateDialog*>(this);
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::hideEvent()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::hideEvent(QHideEvent *event)
{
    TRACE("UntrustedCertificateDialog::hideEvent");
    HbDialog::hideEvent(event);
    emit deviceDialogClosed();
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::showEvent()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::showEvent(QShowEvent *event)
{
    TRACE("UntrustedCertificateDialog::showEvent");
    HbDialog::showEvent(event);
    mShowEventReceived = true;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::isParametersValid()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateDialog::isParametersValid(const QVariantMap &parameters)
{
    if (parameters.contains(KUntrustedCertEncodedCertificate) &&
        parameters.contains(KUntrustedCertServerName) &&
        parameters.contains(KUntrustedCertValidationError)) {
        return true;
        }
    mLastError = KParameterError;
    return false;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::constructDialog()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateDialog::constructDialog(const QVariantMap &parameters)
{
    TRACE("UntrustedCertificateDialog::constructDialog");
    if (!isParametersValid(parameters)) {
        return false;
    }

    setTimeout(HbPopup::NoTimeout);
    setDismissPolicy(HbPopup::NoDismiss);
    setModal(true);

    //: Title text in untrusted certificate dialog. User is opening secure
    //: connection to site or service, which authenticity cannot be proved,
    //: or there are other problems in the site certificate. User needs to
    //: decide if she/he accepts the risk and opens the secure connection
    //: anyway, or if the connection is rejected.
    //TODO: localised UI string
    //QString titleText = hbTrId("");
    QString titleText = tr("Untrusted certificate");
    setHeadingWidget(new HbLabel(titleText, this));

    Q_ASSERT(mContent == 0);
    mContent = new UntrustedCertificateWidget(this);
    mContent->constructFromParameters(parameters);
    setContentWidget(mContent);

    if (mContent->isCertificateValid()) {
        mOkAction = new HbAction(qtTrId("txt_common_button_ok"), this);
        addAction(mOkAction);
        disconnect(mOkAction, SIGNAL(triggered()), this, SLOT(close()));
        connect(mOkAction, SIGNAL(triggered()), this, SLOT(handleAccepted()));

        HbAction *cancelAction = new HbAction(qtTrId("txt_common_button_cancel"), this);
        addAction(cancelAction);
        disconnect(cancelAction, SIGNAL(triggered()), this, SLOT(close()));
        connect(cancelAction, SIGNAL(triggered()), this, SLOT(handleRejected()));
    } else {
        HbAction *closeAction = new HbAction(qtTrId("txt_common_button_close"), this);
        addAction(closeAction);
        disconnect(closeAction, SIGNAL(triggered()), this, SLOT(close()));
        connect(closeAction, SIGNAL(triggered()), this, SLOT(handleRejected()));
    }

    return true;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::updateFromParameters()
// ----------------------------------------------------------------------------
//
bool UntrustedCertificateDialog::updateFromParameters(const QVariantMap &parameters)
{
    TRACE("UntrustedCertificateDialog::updateFromParameters");
    if (!isParametersValid(parameters)) {
        return false;
    }

    Q_ASSERT(mContent != 0);
    mContent->updateFromParameters(parameters);
    return true;
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::sendResult()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::sendResult(int result)
{
    TRACE1("UntrustedCertificateDialog::sendResult", result);
    QVariant resultValue(result);
    mResultMap.insert(KUntrustedCertificateDialogResult, resultValue);
    emit deviceDialogData(mResultMap);
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::confirmPermanentAccept()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::confirmPermanentAccept()
{
    TRACE("UntrustedCertificateDialog::confirmPermanentAccept");

    HbDialog *dialog = new HbDialog();
    dialog->setAttribute(Qt::WA_DeleteOnClose, true);
    dialog->setTimeout(HbPopup::NoTimeout);
    dialog->setDismissPolicy(HbDialog::NoDismiss);
    dialog->setModal(true);

    // TODO: localised UI string needed
    QString questionTitle = tr("Certificate access");
    dialog->setHeadingWidget(new HbLabel(questionTitle));

    HbWidget *widget = new HbWidget();
    QGraphicsLinearLayout* layout = new QGraphicsLinearLayout();
    // TODO: localized UI string needed
    QString questionText =
        tr("Connections to '%1' will be made without warnings. Continue?")
        .arg(mContent->serverName());
    HbLabel *textLabel = new HbLabel(questionText);
    textLabel->setTextWrapping(Hb::TextWordWrap);
    layout->addItem(textLabel);
    widget->setLayout(layout);
    dialog->setContentWidget(widget);

    HbAction *yesAction = new HbAction(hbTrId("txt_common_button_yes"));
    dialog->addAction(yesAction);
    disconnect(yesAction, SIGNAL(triggered()), this, SLOT(close()));
    connect(yesAction, SIGNAL(triggered()), this, SLOT(handlePermanentAcceptance()));
    dialog->addAction(new HbAction(hbTrId("txt_common_button_no")));

    dialog->show();
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::handleAccepted()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::handleAccepted()
{
    TRACE("UntrustedCertificateDialog::handleAccepted");
    if (mContent->isPermanentAcceptChecked()) {
        confirmPermanentAccept();
    } else {
        sendResult(KDialogAccepted);
		close();
    }
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::handleRejected()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::handleRejected()
{
    TRACE("UntrustedCertificateDialog::handleRejected");
    sendResult(KDialogRejected);
    close();
}

// ----------------------------------------------------------------------------
// UntrustedCertificateDialog::handlePermanentAcceptance()
// ----------------------------------------------------------------------------
//
void UntrustedCertificateDialog::handlePermanentAcceptance()
{
    TRACE("UntrustedCertificateDialog::handlePermanentAcceptance");
    sendResult(KDialogAcceptedPermanently);
    close();
}