/*
* 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:  Certificate list view in advanced security settings
*
*/

#include "advsecsettingscertificatelistview.h"
#include "advsecsettingscertificatemodel.h"
#include "advsecsettingscertificatedetailview.h"
#include "advsecsettingscerttrustsettingsview.h"
#include <QGraphicsLinearLayout>
#include <HbAbstractViewItem>
#include <HbGroupBox>
#include <HbListWidget>
#include <HbListWidgetItem>
#include <HbLabel>
#include <HbStackedWidget>


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::AdvSecSettingsCertificateListView()
// ---------------------------------------------------------------------------
//
AdvSecSettingsCertificateListView::AdvSecSettingsCertificateListView(
    QGraphicsItem *parent) : AdvSecSettingsViewBase(0, parent),
    mCertType(AdvSecSettingsCertificate::NotDefined),
    mListWidget(0), mEmptyText(0), mRetrievingText(0), mStackedWidget(0),
    mIsRetrieving(true), mModelCertificateList(), mDisplayedCertificates(),
    mModel(0), mDetailView(), mTrustSettingsView(0), mCurrentCertificate(0)
{
    mModel = new AdvSecSettingsCertificateModel(this);
    mModel->initialize();
    connect(mModel, SIGNAL(initializeCompleted()),
        this, SLOT(readAllCertificatesFromModel()));
    connect(mModel, SIGNAL(getCertificatesCompleted()),
        this, SLOT(displayAllCertificatesReadFromModel()));
    connect(mModel, SIGNAL(deleteCertificateCompleted()),
        this, SLOT(refreshAfterCurrentCertRemoved()));
    connect(mModel, SIGNAL(moveToPersonalCertificatesCompleted()),
        this, SLOT(refreshAfterCurrentCertRemoved()));
    connect(mModel, SIGNAL(moveToDeviceCertificatesCompleted()),
        this, SLOT(refreshAfterCurrentCertRemoved()));
    connect(mModel, SIGNAL(errorOccurred(int)),
        this, SLOT(displayError(int)));

    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(Qt::Vertical);

    // View title
    mViewLabel = new HbGroupBox;
    layout->addItem(mViewLabel);

    // Certificate list or empty text
    mStackedWidget = new HbStackedWidget;

    mListWidget = new HbListWidget;
    connect(mListWidget, SIGNAL(activated(QModelIndex)),
        this, SLOT(openCertificate(QModelIndex)));
    connect(mListWidget, SIGNAL(longPressed(HbAbstractViewItem*, QPointF)),
        this, SLOT(indicateLongPress(HbAbstractViewItem*, QPointF)));
    mStackedWidget->addWidget(mListWidget);

    // TODO: localized UI string needed
    mEmptyText = new HbLabel(tr("No certificates"));
    mEmptyText->setAlignment(Qt::AlignCenter);
    mStackedWidget->addWidget(mEmptyText);

    mRetrievingText = new HbLabel(tr("Retrieving..."));
    mRetrievingText->setAlignment(Qt::AlignCenter);
    mStackedWidget->addWidget(mRetrievingText);

    mStackedWidget->setCurrentWidget(mRetrievingText);
    layout->addItem(mStackedWidget);

    setLayout(layout);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::~AdvSecSettingsCertificateListView()
// ---------------------------------------------------------------------------
//
AdvSecSettingsCertificateListView::~AdvSecSettingsCertificateListView()
{
    clearModelCertificates();
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::displayCertificates()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::displayCertificates(
    AdvSecSettingsCertificate::CertificateType type)
{
    if (type != mCertType) {
        mCertType = type;
        switch (mCertType) {
        case AdvSecSettingsCertificate::AuthorityCertificate:
            mViewLabel->setHeading(hbTrId("txt_certificate_manager_subhead_authority_certific"));
            break;
        case AdvSecSettingsCertificate::TrustedSiteCertificate:
            mViewLabel->setHeading(hbTrId("txt_certificate_manager_subhead_trusted_site_certi"));
            break;
        case AdvSecSettingsCertificate::PersonalCertificate:
            mViewLabel->setHeading(hbTrId("txt_certificate_manager_subhead_personal_certifica"));
            break;
        case AdvSecSettingsCertificate::DeviceCertificate:
            mViewLabel->setHeading(hbTrId("txt_certificate_manager_subhead_device_certificate"));
            break;
        default:
            break;
        }
    }
    refreshDisplayedCertificates();
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::setCurrentIndex()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::setCurrentIndex(const QModelIndex& index)
{
    mListWidget->setCurrentIndex(index, QItemSelectionModel::SelectCurrent);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::indicateLongPress()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::indicateLongPress(
    HbAbstractViewItem *item, const QPointF &position)
{
    Q_ASSERT(item != 0);
    mCurrentCertificate = mDisplayedCertificates.at(item->modelIndex().row());

    clearItemSpecificMenu();
    addItemSpecificMenuAction(hbTrId("txt_common_menu_open"),
        this, SLOT(openCurrentCertificate()));

    switch (mCertType) {
    case AdvSecSettingsCertificate::AuthorityCertificate:
        addItemSpecificMenuAction(hbTrId("txt_certificate_manager_menu_trust_settings"),
            this, SLOT(displayCurrentCertTrustSettings()));
        break;
    case AdvSecSettingsCertificate::TrustedSiteCertificate:
        break;
    case AdvSecSettingsCertificate::PersonalCertificate:
        addItemSpecificMenuAction(hbTrId("txt_certificate_manager_menu_move_to_device_certif"),
            this, SLOT(moveCurrentCertToDeviceCertificates()));
        break;
    case AdvSecSettingsCertificate::DeviceCertificate:
        addItemSpecificMenuAction(hbTrId("txt_certificate_manager_menu_move_to_personal_cert"),
            this, SLOT(moveCurrentCertToPersonalCertificates()));
        break;
    default:
        break;
    }

    Q_ASSERT(mCurrentCertificate != 0);
    if (mModel->isDeletable(*mCurrentCertificate)) {
        addItemSpecificMenuAction(hbTrId("txt_common_menu_delete"),
            this, SLOT(deleteCurrentCertificate()));
    }

    displayItemSpecificMenu(position);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::openCertificate()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::openCertificate(const QModelIndex& modelIndex)
{
    mCurrentCertificate = mDisplayedCertificates.at(modelIndex.row());
    openCurrentCertificate();
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::openCurrentCertificate()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::openCurrentCertificate()
{
    if (!mDetailView) {
        mDetailView = new AdvSecSettingsCertificateDetailView(*mModel, this);
    }
    Q_ASSERT(mCurrentCertificate != 0);
    mDetailView->setCertificate(*mCurrentCertificate);
    displayView(mDetailView);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::displayCurrentCertTrustSettings()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::displayCurrentCertTrustSettings()
{
    if (!mTrustSettingsView) {
        mTrustSettingsView = new AdvSecSettingsCertTrustSettingsView(*mModel, this);
    }
    Q_ASSERT(mCurrentCertificate != 0);
    mTrustSettingsView->setCertificate(*mCurrentCertificate);
    displayView(mTrustSettingsView);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::deleteCurrentCertificate()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::deleteCurrentCertificate()
{
    Q_ASSERT(mCurrentCertificate != 0);
    // TODO: localized UI string needed
    QString confirmText(tr("Delete %1?").arg(mCurrentCertificate->label()));
    displayQuestionNote(confirmText, this, SLOT(deleteConfirmationAccepted()));
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::deleteConfirmationAccepted()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::deleteConfirmationAccepted()
{
    Q_ASSERT(mCurrentCertificate != 0);
    mModel->deleteCertificate(*mCurrentCertificate);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::moveCurrentCertToDeviceCertificates()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::moveCurrentCertToDeviceCertificates()
{
    Q_ASSERT(mCurrentCertificate != 0);
    QString confirmText(hbTrId("txt_certificate_info_device_certificates_can_be_us"));
    displayQuestionNote(confirmText, this, SLOT(moveToDeviceCertsConfirmationAccepted()));
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::moveToDeviceCertsConfirmationAccepted()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::moveToDeviceCertsConfirmationAccepted()
{
    Q_ASSERT(mCurrentCertificate != 0);
    mModel->moveToDeviceCertificates(*mCurrentCertificate);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::moveCurrentCertToPersonalCertificates()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::moveCurrentCertToPersonalCertificates()
{
    Q_ASSERT(mCurrentCertificate != 0);
    // TODO: localized UI string needed
    QString confirmText(tr("Using personal certificates may require user confirmation. Continue?"));
    displayQuestionNote(confirmText, this, SLOT(moveToPersonalCertsConfirmationAccepted()));
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::moveToPersonalCertsConfirmationAccepted()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::moveToPersonalCertsConfirmationAccepted()
{
    Q_ASSERT(mCurrentCertificate != 0);
    mModel->moveToPersonalCertificates(*mCurrentCertificate);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::readAllCertificatesFromModel()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::readAllCertificatesFromModel()
{
    clearModelCertificates();
    mModel->getCertificates(mModelCertificateList);
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::displayAllCertificatesReadFromModel()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::displayAllCertificatesReadFromModel()
{
    if (mCertType != AdvSecSettingsCertificate::NotDefined) {
        mIsRetrieving = false;
        refreshDisplayedCertificates();
    }
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::clearModelCertificates()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::clearModelCertificates()
{
    if (!mModelCertificateList.isEmpty()) {
        QMutableListIterator<AdvSecSettingsCertificate *> iter(mModelCertificateList);
        while (iter.hasNext()) {
            delete iter.next();
        }
        mModelCertificateList.clear();
    }
    mCurrentCertificate = 0;
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::refreshDisplayedCertificates()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::refreshDisplayedCertificates()
{
    int currentRow = mListWidget->currentRow();
    mListWidget->clear();
    mDisplayedCertificates.clear();
    QListIterator<AdvSecSettingsCertificate *> iter(mModelCertificateList);
    while (iter.hasNext()) {
        AdvSecSettingsCertificate *cert = iter.next();
        if (cert->certType() == mCertType) {
            mDisplayedCertificates.append(cert);
            HbListWidgetItem *item = new HbListWidgetItem;
            item->setText(cert->label());
            mListWidget->addItem(item);
        }
    }
    if (mListWidget->count()) {
        if (currentRow < mListWidget->count()) {
            mListWidget->setCurrentRow(currentRow);
        }
        mStackedWidget->setCurrentWidget(mListWidget);
    } else {
        if (mIsRetrieving) {
            mStackedWidget->setCurrentWidget(mRetrievingText);
        } else {
            mStackedWidget->setCurrentWidget(mEmptyText);
        }
    }
}

// ---------------------------------------------------------------------------
// AdvSecSettingsCertificateListView::refreshAfterCurrentCertRemoved()
// ---------------------------------------------------------------------------
//
void AdvSecSettingsCertificateListView::refreshAfterCurrentCertRemoved()
{
    Q_ASSERT(mCurrentCertificate != 0);

    QString currentCertLabel = mCurrentCertificate->label();
    for (TInt row = 0; row < mListWidget->count(); row++) {
        HbListWidgetItem *item = mListWidget->item(row);
        if (item->text() == currentCertLabel) {
            item = mListWidget->takeItem(row);
            delete item;
        }
    }
    if (mListWidget->count()) {
        mStackedWidget->setCurrentWidget(mListWidget);
    } else {
        mStackedWidget->setCurrentWidget(mEmptyText);
    }

    mDisplayedCertificates.removeAll(mCurrentCertificate);
    mCurrentCertificate = 0;

    readAllCertificatesFromModel();
}