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

**

** All rights reserved.

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

**

** This file is part of the demonstration applications of the Qt Toolkit.

**

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

#include "autosaver.h"

#include "browserapplication.h"

#include <QtCore/QBuffer>

#include <QtCore/QDir>

#include <QtCore/QFile>

#include <QtCore/QFileInfo>

#include <QtCore/QSettings>

#include <QtCore/QTemporaryFile>

#include <QtCore/QTextStream>

#include <QtCore/QtAlgorithms>

#include <QtGui/QClipboard>

#include <QtGui/QDesktopServices>

#include <QtGui/QHeaderView>

#include <QtGui/QStyle>

#include <QtWebKit/QWebHistoryInterface>

#include <QtWebKit/QWebSettings>

#include <QtCore/QDebug>

static const unsigned int HISTORY_VERSION = 23;

HistoryManager::HistoryManager(QObject *parent)

    : QWebHistoryInterface(parent)

    , m_saveTimer(new AutoSaver(this))

    , m_historyLimit(30)

    , m_historyModel(0)

    , m_historyFilterModel(0)

    , m_historyTreeModel(0)

{

    m_expiredTimer.setSingleShot(true);

    connect(&m_expiredTimer, SIGNAL(timeout()),

            this, SLOT(checkForExpired()));

    connect(this, SIGNAL(entryAdded(HistoryItem)),

            m_saveTimer, SLOT(changeOccurred()));

    connect(this, SIGNAL(entryRemoved(HistoryItem)),

            m_saveTimer, SLOT(changeOccurred()));

    load();

    m_historyModel = new HistoryModel(this, this);

    m_historyFilterModel = new HistoryFilterModel(m_historyModel, this);

    m_historyTreeModel = new HistoryTreeModel(m_historyFilterModel, this);

    // QWebHistoryInterface will delete the history manager

    QWebHistoryInterface::setDefaultInterface(this);

}

HistoryManager::~HistoryManager()

{

    m_saveTimer->saveIfNeccessary();

}

QList<HistoryItem> HistoryManager::history() const

{

    return m_history;

}

bool HistoryManager::historyContains(const QString &url) const

{

    return m_historyFilterModel->historyContains(url);

}

void HistoryManager::addHistoryEntry(const QString &url)

{

    QUrl cleanUrl(url);

    cleanUrl.setPassword(QString());

    cleanUrl.setHost(cleanUrl.host().toLower());

    HistoryItem item(cleanUrl.toString(), QDateTime::currentDateTime());

    addHistoryItem(item);

}

void HistoryManager::setHistory(const QList<HistoryItem> &history, bool loadedAndSorted)

{

    m_history = history;

    // verify that it is sorted by date

    if (!loadedAndSorted)

        qSort(m_history.begin(), m_history.end());

    checkForExpired();

    if (loadedAndSorted) {

        m_lastSavedUrl = m_history.value(0).url;

    } else {

        m_lastSavedUrl = QString();

        m_saveTimer->changeOccurred();

    }

    emit historyReset();

}

HistoryModel *HistoryManager::historyModel() const

{

    return m_historyModel;

}

HistoryFilterModel *HistoryManager::historyFilterModel() const

{

    return m_historyFilterModel;

}

HistoryTreeModel *HistoryManager::historyTreeModel() const

{

    return m_historyTreeModel;

}

void HistoryManager::checkForExpired()

{

    if (m_historyLimit < 0 || m_history.isEmpty())

        return;

    QDateTime now = QDateTime::currentDateTime();

    int nextTimeout = 0;

    while (!m_history.isEmpty()) {

        QDateTime checkForExpired = m_history.last().dateTime;

        checkForExpired.setDate(checkForExpired.date().addDays(m_historyLimit));

        if (now.daysTo(checkForExpired) > 7) {

            // check at most in a week to prevent int overflows on the timer

            nextTimeout = 7 * 86400;

        } else {

            nextTimeout = now.secsTo(checkForExpired);

        }

        if (nextTimeout > 0)

            break;

        HistoryItem item = m_history.takeLast();

        // remove from saved file also

        m_lastSavedUrl = QString();

        emit entryRemoved(item);

    }

    if (nextTimeout > 0)

        m_expiredTimer.start(nextTimeout * 1000);

}

void HistoryManager::addHistoryItem(const HistoryItem &item)

{

    QWebSettings *globalSettings = QWebSettings::globalSettings();

    if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))

        return;

    m_history.prepend(item);

    emit entryAdded(item);

    if (m_history.count() == 1)

        checkForExpired();

}

void HistoryManager::updateHistoryItem(const QUrl &url, const QString &title)

{

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

        if (url == m_history.at(i).url) {

            m_history[i].title = title;

            m_saveTimer->changeOccurred();

            if (m_lastSavedUrl.isEmpty())

                m_lastSavedUrl = m_history.at(i).url;

            emit entryUpdated(i);

            break;

        }

    }

}

int HistoryManager::historyLimit() const

{

    return m_historyLimit;

}

void HistoryManager::setHistoryLimit(int limit)

{

    if (m_historyLimit == limit)

        return;

    m_historyLimit = limit;

    checkForExpired();

    m_saveTimer->changeOccurred();

}

void HistoryManager::clear()

{

    m_history.clear();

    m_lastSavedUrl = QString();

    m_saveTimer->changeOccurred();

    m_saveTimer->saveIfNeccessary();

    historyReset();

}

void HistoryManager::loadSettings()

{

    // load settings

    QSettings settings;

    settings.beginGroup(QLatin1String("history"));

    m_historyLimit = settings.value(QLatin1String("historyLimit"), 30).toInt();

}

void HistoryManager::load()

{

    loadSettings();

    QFile historyFile(QDesktopServices::storageLocation(QDesktopServices::DataLocation)

        + QLatin1String("/history"));

    if (!historyFile.exists())

        return;

    if (!historyFile.open(QFile::ReadOnly)) {

        qWarning() << "Unable to open history file" << historyFile.fileName();

        return;

    }

    QList<HistoryItem> list;

    QDataStream in(&historyFile);

    // Double check that the history file is sorted as it is read in

    bool needToSort = false;

    HistoryItem lastInsertedItem;

    QByteArray data;

    QDataStream stream;

    QBuffer buffer;

    stream.setDevice(&buffer);

    while (!historyFile.atEnd()) {

        in >> data;

        buffer.close();

        buffer.setBuffer(&data);

        buffer.open(QIODevice::ReadOnly);

        quint32 ver;

        stream >> ver;

        if (ver != HISTORY_VERSION)

            continue;

        HistoryItem item;

        stream >> item.url;

        stream >> item.dateTime;

        stream >> item.title;

        if (!item.dateTime.isValid())

            continue;

        if (item == lastInsertedItem) {

            if (lastInsertedItem.title.isEmpty() && !list.isEmpty())

                list[0].title = item.title;

            continue;

        }

        if (!needToSort && !list.isEmpty() && lastInsertedItem < item)

            needToSort = true;

        list.prepend(item);

        lastInsertedItem = item;

    }

    if (needToSort)

        qSort(list.begin(), list.end());

    setHistory(list, true);

    // If we had to sort re-write the whole history sorted

    if (needToSort) {

        m_lastSavedUrl = QString();

        m_saveTimer->changeOccurred();

    }

}

void HistoryManager::save()

{

    QSettings settings;

    settings.beginGroup(QLatin1String("history"));

    settings.setValue(QLatin1String("historyLimit"), m_historyLimit);

    bool saveAll = m_lastSavedUrl.isEmpty();

    int first = m_history.count() - 1;

    if (!saveAll) {

        // find the first one to save

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

            if (m_history.at(i).url == m_lastSavedUrl) {

                first = i - 1;

                break;

            }

        }

    }

    if (first == m_history.count() - 1)

        saveAll = true;

    QString directory = QDesktopServices::storageLocation(QDesktopServices::DataLocation);

    if (directory.isEmpty())

        directory = QDir::homePath() + QLatin1String("/.") + QCoreApplication::applicationName();

    if (!QFile::exists(directory)) {

        QDir dir;

        dir.mkpath(directory);

    }

    QFile historyFile(directory + QLatin1String("/history"));

    // When saving everything use a temporary file to prevent possible data loss.

    QTemporaryFile tempFile;

    tempFile.setAutoRemove(false);

    bool open = false;

    if (saveAll) {

        open = tempFile.open();

    } else {

        open = historyFile.open(QFile::Append);

    }

    if (!open) {

        qWarning() << "Unable to open history file for saving"

                   << (saveAll ? tempFile.fileName() : historyFile.fileName());

        return;

    }

    QDataStream out(saveAll ? &tempFile : &historyFile);

    for (int i = first; i >= 0; --i) {

        QByteArray data;

        QDataStream stream(&data, QIODevice::WriteOnly);

        HistoryItem item = m_history.at(i);

        stream << HISTORY_VERSION << item.url << item.dateTime << item.title;

        out << data;

    }

    tempFile.close();

    if (saveAll) {

        if (historyFile.exists() && !historyFile.remove())

            qWarning() << "History: error removing old history." << historyFile.errorString();

        if (!tempFile.rename(historyFile.fileName()))

            qWarning() << "History: error moving new history over old." << tempFile.errorString() << historyFile.fileName();

    }

    m_lastSavedUrl = m_history.value(0).url;

}

HistoryModel::HistoryModel(HistoryManager *history, QObject *parent)

    : QAbstractTableModel(parent)

    , m_history(history)

{

    Q_ASSERT(m_history);

    connect(m_history, SIGNAL(historyReset()),

            this, SLOT(historyReset()));

    connect(m_history, SIGNAL(entryRemoved(HistoryItem)),

            this, SLOT(historyReset()));

    connect(m_history, SIGNAL(entryAdded(HistoryItem)),

            this, SLOT(entryAdded()));

    connect(m_history, SIGNAL(entryUpdated(int)),

            this, SLOT(entryUpdated(int)));

}

void HistoryModel::historyReset()

{

    reset();

}

void HistoryModel::entryAdded()

{

    beginInsertRows(QModelIndex(), 0, 0);

    endInsertRows();

}

void HistoryModel::entryUpdated(int offset)

{

    QModelIndex idx = index(offset, 0);

    emit dataChanged(idx, idx);

}

QVariant HistoryModel::headerData(int section, Qt::Orientation orientation, int role) const

{

    if (orientation == Qt::Horizontal

        && role == Qt::DisplayRole) {

        switch (section) {

            case 0: return tr("Title");

            case 1: return tr("Address");

        }

    }

    return QAbstractTableModel::headerData(section, orientation, role);

}

QVariant HistoryModel::data(const QModelIndex &index, int role) const

{

    QList<HistoryItem> lst = m_history->history();

    if (index.row() < 0 || index.row() >= lst.size())

        return QVariant();

    const HistoryItem &item = lst.at(index.row());

    switch (role) {

    case DateTimeRole:

        return item.dateTime;

    case DateRole:

        return item.dateTime.date();

    case UrlRole:

        return QUrl(item.url);

    case UrlStringRole:

        return item.url;

    case Qt::DisplayRole:

    case Qt::EditRole: {

        switch (index.column()) {

            case 0:

                // when there is no title try to generate one from the url

                if (item.title.isEmpty()) {

                    QString page = QFileInfo(QUrl(item.url).path()).fileName();

                    if (!page.isEmpty())

                        return page;

                    return item.url;

                }

                return item.title;

            case 1:

                return item.url;

        }

        }

    case Qt::DecorationRole:

        if (index.column() == 0) {

            return BrowserApplication::instance()->icon(item.url);

        }

    }

    return QVariant();

}

int HistoryModel::columnCount(const QModelIndex &parent) const

{

    return (parent.isValid()) ? 0 : 2;

}

int HistoryModel::rowCount(const QModelIndex &parent) const

{

    return (parent.isValid()) ? 0 : m_history->history().count();

}

bool HistoryModel::removeRows(int row, int count, const QModelIndex &parent)

{

    if (parent.isValid())

        return false;

    int lastRow = row + count - 1;

    beginRemoveRows(parent, row, lastRow);

    QList<HistoryItem> lst = m_history->history();

    for (int i = lastRow; i >= row; --i)

        lst.removeAt(i);

    disconnect(m_history, SIGNAL(historyReset()), this, SLOT(historyReset()));

    m_history->setHistory(lst);

    connect(m_history, SIGNAL(historyReset()), this, SLOT(historyReset()));

    endRemoveRows();

    return true;

}

#define MOVEDROWS 15

/*

    Maps the first bunch of items of the source model to the root

*/

HistoryMenuModel::HistoryMenuModel(HistoryTreeModel *sourceModel, QObject *parent)

    : QAbstractProxyModel(parent)

    , m_treeModel(sourceModel)

{

    setSourceModel(sourceModel);

}

int HistoryMenuModel::bumpedRows() const

{

    QModelIndex first = m_treeModel->index(0, 0);

    if (!first.isValid())

        return 0;

    return qMin(m_treeModel->rowCount(first), MOVEDROWS);

}

int HistoryMenuModel::columnCount(const QModelIndex &parent) const

{

    return m_treeModel->columnCount(mapToSource(parent));

}

int HistoryMenuModel::rowCount(const QModelIndex &parent) const

{

    if (parent.column() > 0)

        return 0;

    if (!parent.isValid()) {

        int folders = sourceModel()->rowCount();

        int bumpedItems = bumpedRows();

        if (bumpedItems <= MOVEDROWS

            && bumpedItems == sourceModel()->rowCount(sourceModel()->index(0, 0)))

            --folders;

        return bumpedItems + folders;

    }

    if (parent.internalId() == -1) {

        if (parent.row() < bumpedRows())

            return 0;

    }

    QModelIndex idx = mapToSource(parent);

    int defaultCount = sourceModel()->rowCount(idx);

    if (idx == sourceModel()->index(0, 0))

        return defaultCount - bumpedRows();

    return defaultCount;

}

QModelIndex HistoryMenuModel::mapFromSource(const QModelIndex &sourceIndex) const