/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "mainwindow.h"

#include "attachmentlistwidget.h"

#include "qmessageservice.h"

#include <qmessagemanager.h>

#include <QComboBox>

#include <QListWidget>

#include <QVBoxLayout>

#include <QLabel>

#include <QTabWidget>

#include <QPointer>

#include <QPushButton>

#include <QDebug>

#include <QLineEdit>

#include <QTextEdit>

#include <QTextBrowser>

#include <QFileDialog>

#include <QTimer>

#include <QMessageBox>

#include <QThread>

#include <QStackedLayout>

#include <QPair>

#include <QScrollArea>

#include <QMenuBar>

#include <QApplication>

#include <QStackedWidget>

#include <QMutex>

#include <QKeyEvent>

static const QSize WindowGeometry(400,300);

static const QString WindowTitle("Service-actions Example");

static unsigned int RecentMessagesCount = 50;

class AccountsWidget : public QWidget

{

    Q_OBJECT

private:

    class Loader : public QThread

    {

    public:

        Loader(AccountsWidget* parent);

        void run();

    private:

        AccountsWidget* m_parent;

    };

public:

    AccountsWidget(QWidget* parent = 0);

    QMessageAccountId currentAccount() const;

    QString currentAccountName() const;

    bool isEmpty() const;

signals:

    void accountChanged();

protected:

    void showEvent(QShowEvent* e);

    void hideEvent(QHideEvent* e);

private slots:

    void load();

    void loadStarted();

    void loadFinished();

private:

    void setupUi();

    void setIds(const QMessageAccountIdList& ids);

    QMessageAccountIdList ids() const;

private:

    QStackedLayout* m_stackedLayout;

    QComboBox* m_accountsCombo;

    QLabel* m_busyLabel;

    Loader m_loader;

    mutable QMutex m_loadMutex;

    QMessageAccountIdList m_ids;

};

AccountsWidget::Loader::Loader(AccountsWidget* parent)

:

QThread(parent),

m_parent(parent)

{

}

void AccountsWidget::Loader::run()

{

    QMessageManager manager;

    m_parent->setIds(manager.queryAccounts());

}

AccountsWidget::AccountsWidget(QWidget* parent)

:

QWidget(parent),

m_stackedLayout(0),

m_accountsCombo(0),

m_busyLabel(0),

m_loader(this)

{

    setupUi();

    connect(&m_loader,SIGNAL(started()),this,SLOT(loadStarted()));

    connect(&m_loader,SIGNAL(finished()),this,SLOT(loadFinished()));

}

QMessageAccountId AccountsWidget::currentAccount() const

{

    QMessageAccountId result;

    if(m_loader.isFinished() && m_accountsCombo->count())

    {

        int index = m_accountsCombo->currentIndex();

        return ids().at(index);

    }

    return result;

}

QString AccountsWidget::currentAccountName() const

{

    if(m_loader.isFinished() && m_accountsCombo->count())

        return m_accountsCombo->itemData(m_accountsCombo->currentIndex()).toString();

    return QString();

}

bool AccountsWidget::isEmpty() const

{

    return m_accountsCombo->count() == 0;

}

void AccountsWidget::showEvent(QShowEvent* e)

{

    load();

    QWidget::showEvent(e);

}

void AccountsWidget::hideEvent(QHideEvent* e)

{

    if(m_loader.isRunning())

        m_loader.exit();

    QWidget::hideEvent(e);

}

void AccountsWidget::load()

{

    static bool runonce = false;

    if(!runonce)

        m_loader.start();

    runonce = true;

}

void AccountsWidget::loadStarted()

{

#ifndef _WIN32_WCE

    setCursor(Qt::BusyCursor);

#endif

    m_stackedLayout->setCurrentWidget(m_busyLabel);

}

void AccountsWidget::loadFinished()

{

    m_accountsCombo->clear();

    QMessageAccountIdList accountIds = ids();

    if(!accountIds.isEmpty())

    {

        for(int i = 0; i < accountIds.count(); ++i)

        {

            QMessageAccount account(accountIds[i]);

            m_accountsCombo->addItem(QString("%1 - %2").arg(i+1).arg(account.name()),account.name());

        }

        m_stackedLayout->setCurrentWidget(m_accountsCombo);

    }

    else

        m_busyLabel->setText("No accounts!");

#ifndef _WIN32_WCE

    setCursor(Qt::ArrowCursor);

#endif

}

void AccountsWidget::setupUi()

{

    m_stackedLayout = new QStackedLayout(this);

    m_accountsCombo = new QComboBox(this);

    m_stackedLayout->addWidget(m_accountsCombo);

    connect(m_accountsCombo,SIGNAL(currentIndexChanged(int)),this,SIGNAL(accountChanged()));

    m_busyLabel = new QLabel("Loading...");

    m_stackedLayout->addWidget(m_busyLabel);

    setSizePolicy(m_accountsCombo->sizePolicy());

}

void AccountsWidget::setIds(const QMessageAccountIdList& ids)

{

    QMutexLocker mutex(&m_loadMutex);

    m_ids = ids;

}

QMessageAccountIdList AccountsWidget::ids() const

{

    QMutexLocker mutex(&m_loadMutex);

    return m_ids;

}

class RecentMessagesWidget : public QWidget

{

    Q_OBJECT

public:

    RecentMessagesWidget(QWidget* parent = 0, unsigned int maxRecent = 10);

    ~RecentMessagesWidget();

    QMessageId currentMessage() const;

signals:

    void selected(const QMessageId& messageId);

protected:

    void showEvent(QShowEvent* e);

    void hideEvent(QHideEvent* e);

private slots:

    void currentItemChanged(QListWidgetItem* current, QListWidgetItem* previous);

    void messagesFound(const QMessageIdList& result);

    void stateChanged(QMessageService::State s);

    void messageUpdated(const QMessageId& id, const QMessageManager::NotificationFilterIdSet& filter);

    void messageRemoved(const QMessageId& id, const QMessageManager::NotificationFilterIdSet& filter);

    void processResults();

private:

    void setupUi();

    void updateState();

    void load();

private:

    enum State { Unloaded, Loading, LoadFinished, Processing, LoadFailed, Done };

    static const int MessageIdRole = Qt::UserRole + 1;

private:

    QListWidget* m_messageListWidget;

    QLabel* m_statusLabel;

    QStackedLayout* m_layout;

    QMessageIdList m_ids;

    QMap<QMessageId,QListWidgetItem*> m_indexMap;

    unsigned int m_maxRecent;

    QMessageService* m_service;

    State m_state;

    QMessageManager::NotificationFilterId m_storeFilterId;

    QMessageManager m_manager;

};

RecentMessagesWidget::RecentMessagesWidget(QWidget* parent, unsigned int maxRecent)

:

QWidget(parent),

m_messageListWidget(0),

m_statusLabel(0),

m_layout(0),

m_maxRecent(maxRecent),

m_service(new QMessageService(this)),

m_state(Unloaded)

{

    setupUi();

    connect(m_service,SIGNAL(messagesFound(const QMessageIdList&)),this,SLOT(messagesFound(const QMessageIdList&)));

    connect(m_service,SIGNAL(stateChanged(QMessageService::State)),this,SLOT(stateChanged(QMessageService::State)));

    //register for message update notifications

    connect(&m_manager, SIGNAL(messageUpdated(const QMessageId&, const QMessageManager::NotificationFilterIdSet&)),

        this, SLOT(messageUpdated(const QMessageId&, const QMessageManager::NotificationFilterIdSet&)));

    connect(&m_manager, SIGNAL(messageRemoved(const QMessageId&, const QMessageManager::NotificationFilterIdSet&)),

        this, SLOT(messageRemoved(const QMessageId&, const QMessageManager::NotificationFilterIdSet&)));

    m_storeFilterId = m_manager.registerNotificationFilter(QMessageFilter());

}

RecentMessagesWidget::~RecentMessagesWidget()

{

     m_manager.unregisterNotificationFilter(m_storeFilterId);

}

QMessageId RecentMessagesWidget::currentMessage() const

{

    QMessageId result;

    if(QListWidgetItem* currentItem = m_messageListWidget->currentItem())

        result = QMessageId(currentItem->data(MessageIdRole).toString());

    return result;

}

void RecentMessagesWidget::showEvent(QShowEvent* e)

{

    if(m_state == Unloaded)

        load();

    updateState();

    QWidget::showEvent(e);

}

void RecentMessagesWidget::hideEvent(QHideEvent* e)

{

    if(m_state == Loading || m_state == Processing)

    {

        m_service->cancel();

        m_state = Unloaded;

        m_ids.clear();

    }

    QWidget::hideEvent(e);

}

void RecentMessagesWidget::currentItemChanged(QListWidgetItem*, QListWidgetItem*)

{

    if(m_state != Processing || m_state != Loading)

        emit selected(currentMessage());

}

//! [process-results]

void RecentMessagesWidget::messagesFound(const QMessageIdList& ids)

{

    m_ids.append(ids);

}

//! [process-results]

void RecentMessagesWidget::stateChanged(QMessageService::State newState)

{

    if (newState == QMessageService::FinishedState) {

        if ((m_state != LoadFailed) && (m_service->error() == QMessageManager::NoError)) {

            m_state = LoadFinished;

        } else {

            m_state = LoadFailed;

        }

    }

    updateState();

}

void RecentMessagesWidget::messageUpdated(const QMessageId& id, const QMessageManager::NotificationFilterIdSet& filter)

{

    if(!filter.contains(m_storeFilterId) || m_state == Loading || !id.isValid() || !m_indexMap.contains(id))

        return;

    //update the pertinent entry to reflect completeness

    QListWidgetItem* item = m_indexMap.value(id);

    if(item)

    {

        QMessage message(id);

        bool partialMessage = !message.find(message.bodyId()).isContentAvailable();

        QFont itemFont = item->font();

        itemFont.setItalic(partialMessage);

        item->setFont(itemFont);

    }

}

void RecentMessagesWidget::messageRemoved(const QMessageId& id, const QMessageManager::NotificationFilterIdSet& filter)

{

    if(!filter.contains(m_storeFilterId) || m_state == Loading || !id.isValid() || !m_indexMap.contains(id))

        return;

    QListWidgetItem* item = m_indexMap.value(id);

    if(item)

    {

        int row = m_messageListWidget->row(item);

        QListWidgetItem* item = m_messageListWidget->takeItem(row);

        m_indexMap.remove(id);

        delete item;

    }

    m_ids.removeAll(id);

}

void RecentMessagesWidget::setupUi()

{

    m_layout = new QStackedLayout(this);

    m_messageListWidget = new QListWidget(this);

    m_layout->addWidget(m_messageListWidget);

    connect(m_messageListWidget,SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),

        this,SLOT(currentItemChanged(QListWidgetItem*,QListWidgetItem*)));

    m_statusLabel = new QLabel(this);

    m_statusLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

    m_statusLabel->setFrameStyle(QFrame::Box);

    m_layout->addWidget(m_statusLabel);

}

void RecentMessagesWidget::updateState()

{

    switch(m_state)

    {

        case Unloaded:

        {

            m_statusLabel->setText(QString());

            m_layout->setCurrentWidget(m_statusLabel);

        }

        break;

        case Loading:

        {

            m_statusLabel->setText("Loading...");

            m_layout->setCurrentWidget(m_statusLabel);

        }

        break;

        case LoadFinished:

        {

            if(m_ids.isEmpty())

            {

                m_statusLabel->setText("Finished. No messages.");

                m_layout->setCurrentWidget(m_statusLabel);

            }

            else

            {

                m_state = Processing;

                updateState();

                processResults();

            }

        }

        break;

        case Processing:

            m_layout->setCurrentWidget(m_messageListWidget);

        break;

        case LoadFailed:

        {

            m_statusLabel->setText("Load failed!");

            m_layout->setCurrentWidget(m_statusLabel);

        }

        break;

    }

#ifndef _WIN32_WCE

    if(m_state == Loading || m_state == Processing)

        setCursor(Qt::BusyCursor);

    else

        setCursor(Qt::ArrowCursor);

#endif

}

//! [load-message]

void RecentMessagesWidget::load()

{

    m_ids.clear();

    if(!m_service->queryMessages(QMessageFilter(),QMessageSortOrder::byReceptionTimeStamp(Qt::DescendingOrder),m_maxRecent))

        m_state = LoadFailed;

    else

        m_state = Loading;

}

//! [load-message]

//! [process-results2]

void RecentMessagesWidget::processResults()

{

    if(!m_ids.isEmpty())

    {

        QMessageId id = m_ids.takeFirst();

        QMessage message(id);

        QListWidgetItem* newItem = new QListWidgetItem(message.subject());

        newItem->setData(MessageIdRole,id.toString());

        QFont itemFont = newItem->font();

        bool isPartialMessage = !message.find(message.bodyId()).isContentAvailable();

        itemFont.setItalic(isPartialMessage);

        newItem->setFont(itemFont);

        m_messageListWidget->addItem(newItem);

        m_indexMap.insert(id,newItem);

        m_messageListWidget->update();

        QTimer::singleShot(100,this,SLOT(processResults()));

    }

    else

    {

        m_state = Done;

        updateState();

    }

}

//! [process-results2]