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

**

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

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

#include "autosaver.h"

#include "browserapplication.h"

#include "history.h"

#include "xbel.h"

#include <QtCore/QBuffer>

#include <QtCore/QFile>

#include <QtCore/QMimeData>

#include <QtGui/QDesktopServices>

#include <QtGui/QDragEnterEvent>

#include <QtGui/QFileDialog>

#include <QtGui/QHeaderView>

#include <QtGui/QIcon>

#include <QtGui/QMessageBox>

#include <QtGui/QToolButton>

#include <QtWebKit/QWebSettings>

#include <QtCore/QDebug>

#define BOOKMARKBAR "Bookmarks Bar"

#define BOOKMARKMENU "Bookmarks Menu"

BookmarksManager::BookmarksManager(QObject *parent)

    : QObject(parent)

    , m_loaded(false)

    , m_saveTimer(new AutoSaver(this))

    , m_bookmarkRootNode(0)

    , m_bookmarkModel(0)

{

    connect(this, SIGNAL(entryAdded(BookmarkNode*)),

            m_saveTimer, SLOT(changeOccurred()));

    connect(this, SIGNAL(entryRemoved(BookmarkNode*,int,BookmarkNode*)),

            m_saveTimer, SLOT(changeOccurred()));

    connect(this, SIGNAL(entryChanged(BookmarkNode*)),

            m_saveTimer, SLOT(changeOccurred()));

}

BookmarksManager::~BookmarksManager()

{

    m_saveTimer->saveIfNeccessary();

}

void BookmarksManager::changeExpanded()

{

    m_saveTimer->changeOccurred();

}

void BookmarksManager::load()

{

    if (m_loaded)

        return;

    m_loaded = true;

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

    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");

    if (!QFile::exists(bookmarkFile))

        bookmarkFile = QLatin1String(":defaultbookmarks.xbel");

    XbelReader reader;

    m_bookmarkRootNode = reader.read(bookmarkFile);

    if (reader.error() != QXmlStreamReader::NoError) {

        QMessageBox::warning(0, QLatin1String("Loading Bookmark"),

            tr("Error when loading bookmarks on line %1, column %2:\n"

               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));

    }

    BookmarkNode *toolbar = 0;

    BookmarkNode *menu = 0;

    QList<BookmarkNode*> others;

    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {

        BookmarkNode *node = m_bookmarkRootNode->children().at(i);

        if (node->type() == BookmarkNode::Folder) {

            // Automatically convert

            if (node->title == tr("Toolbar Bookmarks") && !toolbar) {

                node->title = tr(BOOKMARKBAR);

            }

            if (node->title == tr(BOOKMARKBAR) && !toolbar) {

                toolbar = node;

            }

            // Automatically convert

            if (node->title == tr("Menu") && !menu) {

                node->title = tr(BOOKMARKMENU);

            }

            if (node->title == tr(BOOKMARKMENU) && !menu) {

                menu = node;

            }

        } else {

            others.append(node);

        }

        m_bookmarkRootNode->remove(node);

    }

    Q_ASSERT(m_bookmarkRootNode->children().count() == 0);

    if (!toolbar) {

        toolbar = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode);

        toolbar->title = tr(BOOKMARKBAR);

    } else {

        m_bookmarkRootNode->add(toolbar);

    }

    if (!menu) {

        menu = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode);

        menu->title = tr(BOOKMARKMENU);

    } else {

        m_bookmarkRootNode->add(menu);

    }

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

        menu->add(others.at(i));

}

void BookmarksManager::save() const

{

    if (!m_loaded)

        return;

    XbelWriter writer;

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

    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");

    if (!writer.write(bookmarkFile, m_bookmarkRootNode))

        qWarning() << "BookmarkManager: error saving to" << bookmarkFile;

}

void BookmarksManager::addBookmark(BookmarkNode *parent, BookmarkNode *node, int row)

{

    if (!m_loaded)

        return;

    Q_ASSERT(parent);

    InsertBookmarksCommand *command = new InsertBookmarksCommand(this, parent, node, row);

    m_commands.push(command);

}

void BookmarksManager::removeBookmark(BookmarkNode *node)

{

    if (!m_loaded)

        return;

    Q_ASSERT(node);

    BookmarkNode *parent = node->parent();

    int row = parent->children().indexOf(node);

    RemoveBookmarksCommand *command = new RemoveBookmarksCommand(this, parent, row);

    m_commands.push(command);

}

void BookmarksManager::setTitle(BookmarkNode *node, const QString &newTitle)

{

    if (!m_loaded)

        return;

    Q_ASSERT(node);

    ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newTitle, true);

    m_commands.push(command);

}

void BookmarksManager::setUrl(BookmarkNode *node, const QString &newUrl)

{

    if (!m_loaded)

        return;

    Q_ASSERT(node);

    ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newUrl, false);

    m_commands.push(command);

}

BookmarkNode *BookmarksManager::bookmarks()

{

    if (!m_loaded)

        load();

    return m_bookmarkRootNode;

}

BookmarkNode *BookmarksManager::menu()

{

    if (!m_loaded)

        load();

    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {

        BookmarkNode *node = m_bookmarkRootNode->children().at(i);

        if (node->title == tr(BOOKMARKMENU))

            return node;

    }

    Q_ASSERT(false);

    return 0;

}

BookmarkNode *BookmarksManager::toolbar()

{

    if (!m_loaded)

        load();

    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {

        BookmarkNode *node = m_bookmarkRootNode->children().at(i);

        if (node->title == tr(BOOKMARKBAR))

            return node;

    }

    Q_ASSERT(false);

    return 0;

}

BookmarksModel *BookmarksManager::bookmarksModel()

{

    if (!m_bookmarkModel)

        m_bookmarkModel = new BookmarksModel(this, this);

    return m_bookmarkModel;

}

void BookmarksManager::importBookmarks()

{

    QString fileName = QFileDialog::getOpenFileName(0, tr("Open File"),

                                                     QString(),

                                                     tr("XBEL (*.xbel *.xml)"));

    if (fileName.isEmpty())

        return;

    XbelReader reader;

    BookmarkNode *importRootNode = reader.read(fileName);

    if (reader.error() != QXmlStreamReader::NoError) {

        QMessageBox::warning(0, QLatin1String("Loading Bookmark"),

            tr("Error when loading bookmarks on line %1, column %2:\n"

               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));

    }

    importRootNode->setType(BookmarkNode::Folder);

    importRootNode->title = (tr("Imported %1").arg(QDate::currentDate().toString(Qt::SystemLocaleShortDate)));

    addBookmark(menu(), importRootNode);

}

void BookmarksManager::exportBookmarks()

{

    QString fileName = QFileDialog::getSaveFileName(0, tr("Save File"),

                                tr("%1 Bookmarks.xbel").arg(QCoreApplication::applicationName()),

                                tr("XBEL (*.xbel *.xml)"));

    if (fileName.isEmpty())

        return;

    XbelWriter writer;

    if (!writer.write(fileName, m_bookmarkRootNode))

        QMessageBox::critical(0, tr("Export error"), tr("error saving bookmarks"));

}

RemoveBookmarksCommand::RemoveBookmarksCommand(BookmarksManager *m_bookmarkManagaer, BookmarkNode *parent, int row)

    : QUndoCommand(BookmarksManager::tr("Remove Bookmark"))

    , m_row(row)

    , m_bookmarkManagaer(m_bookmarkManagaer)

    , m_node(parent->children().value(row))

    , m_parent(parent)

    , m_done(false)

{

}

RemoveBookmarksCommand::~RemoveBookmarksCommand()

{

    if (m_done && !m_node->parent()) {

        delete m_node;

    }

}

void RemoveBookmarksCommand::undo()

{

    m_parent->add(m_node, m_row);

    emit m_bookmarkManagaer->entryAdded(m_node);

    m_done = false;

}

void RemoveBookmarksCommand::redo()

{

    m_parent->remove(m_node);

    emit m_bookmarkManagaer->entryRemoved(m_parent, m_row, m_node);

    m_done = true;

}

InsertBookmarksCommand::InsertBookmarksCommand(BookmarksManager *m_bookmarkManagaer,

                BookmarkNode *parent, BookmarkNode *node, int row)

    : RemoveBookmarksCommand(m_bookmarkManagaer, parent, row)

{

    setText(BookmarksManager::tr("Insert Bookmark"));

    m_node = node;

}

ChangeBookmarkCommand::ChangeBookmarkCommand(BookmarksManager *m_bookmarkManagaer, BookmarkNode *node,

                        const QString &newValue, bool title)

    : QUndoCommand()

    , m_bookmarkManagaer(m_bookmarkManagaer)

    , m_title(title)

    , m_newValue(newValue)

    , m_node(node)

{

    if (m_title) {

        m_oldValue = m_node->title;

        setText(BookmarksManager::tr("Name Change"));

    } else {

        m_oldValue = m_node->url;

        setText(BookmarksManager::tr("Address Change"));

    }

}

void ChangeBookmarkCommand::undo()

{

    if (m_title)

        m_node->title = m_oldValue;

    else

        m_node->url = m_oldValue;

    emit m_bookmarkManagaer->entryChanged(m_node);

}

void ChangeBookmarkCommand::redo()

{

    if (m_title)

        m_node->title = m_newValue;

    else

        m_node->url = m_newValue;

    emit m_bookmarkManagaer->entryChanged(m_node);

}

BookmarksModel::BookmarksModel(BookmarksManager *bookmarkManager, QObject *parent)

    : QAbstractItemModel(parent)

    , m_endMacro(false)

    , m_bookmarksManager(bookmarkManager)

{

    connect(bookmarkManager, SIGNAL(entryAdded(BookmarkNode*)),

            this, SLOT(entryAdded(BookmarkNode*)));

    connect(bookmarkManager, SIGNAL(entryRemoved(BookmarkNode*,int,BookmarkNode*)),

            this, SLOT(entryRemoved(BookmarkNode*,int,BookmarkNode*)));

    connect(bookmarkManager, SIGNAL(entryChanged(BookmarkNode*)),

            this, SLOT(entryChanged(BookmarkNode*)));

}

QModelIndex BookmarksModel::index(BookmarkNode *node) const

{

    BookmarkNode *parent = node->parent();

    if (!parent)

        return QModelIndex();

    return createIndex(parent->children().indexOf(node), 0, node);

}

void BookmarksModel::entryAdded(BookmarkNode *item)

{

    Q_ASSERT(item && item->parent());

    int row = item->parent()->children().indexOf(item);

    BookmarkNode *parent = item->parent();

    // item was already added so remove beore beginInsertRows is called

    parent->remove(item);

    beginInsertRows(index(parent), row, row);

    parent->add(item, row);

    endInsertRows();

}

void BookmarksModel::entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item)

{

    // item was already removed, re-add so beginRemoveRows works

    parent->add(item, row);

    beginRemoveRows(index(parent), row, row);

    parent->remove(item);

    endRemoveRows();

}

void BookmarksModel::entryChanged(BookmarkNode *item)

{

    QModelIndex idx = index(item);

    emit dataChanged(idx, idx);

}

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

{

    if (row < 0 || count <= 0 || row + count > rowCount(parent))

        return false;

    BookmarkNode *bookmarkNode = node(parent);

    for (int i = row + count - 1; i >= row; --i) {

        BookmarkNode *node = bookmarkNode->children().at(i);

        if (node == m_bookmarksManager->menu()

            || node == m_bookmarksManager->toolbar())

            continue;

        m_bookmarksManager->removeBookmark(node);

    }

    if (m_endMacro) {

        m_bookmarksManager->undoRedoStack()->endMacro();

        m_endMacro = false;

    }

    return true;

}

QVariant BookmarksModel::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 QAbstractItemModel::headerData(section, orientation, role);

}

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

{

    if (!index.isValid() || index.model() != this)

        return QVariant();

    const BookmarkNode *bookmarkNode = node(index);

    switch (role) {

    case Qt::EditRole:

    case Qt::DisplayRole:

        if (bookmarkNode->type() == BookmarkNode::Separator) {

            switch (index.column()) {

            case 0: return QString(50, 0xB7);

            case 1: return QString();

            }

        }

        switch (index.column()) {

        case 0: return bookmarkNode->title;

        case 1: return bookmarkNode->url;

        }

        break;

    case BookmarksModel::UrlRole:

        return QUrl(bookmarkNode->url);

        break;

    case BookmarksModel::UrlStringRole:

        return bookmarkNode->url;

        break;

    case BookmarksModel::TypeRole:

        return bookmarkNode->type();

        break;

    case BookmarksModel::SeparatorRole:

        return (bookmarkNode->type() == BookmarkNode::Separator);

        break;

    case Qt::DecorationRole:

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

            if (bookmarkNode->type() == BookmarkNode::Folder)

                return QApplication::style()->standardIcon(QStyle::SP_DirIcon);

            return BrowserApplication::instance()->icon(bookmarkNode->url);

        }

    }

    return QVariant();

}

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

{

    return (parent.column() > 0) ? 0 : 2;

}

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

{

    if (parent.column() > 0)

        return 0;

    if (!parent.isValid())

        return m_bookmarksManager->bookmarks()->children().count();

    const BookmarkNode *item = static_cast<BookmarkNode*>(parent.internalPointer());

    return item->children().count();

}

QModelIndex BookmarksModel::index(int row, int column, const QModelIndex &parent) const

{

    if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))

        return QModelIndex();

    // get the parent node

    BookmarkNode *parentNode = node(parent);

    return createIndex(row, column, parentNode->children().at(row));

}

QModelIndex BookmarksModel::parent(const QModelIndex &index) const

{

    if (!index.isValid())

        return QModelIndex();

    BookmarkNode *itemNode = node(index);

    BookmarkNode *parentNode = (itemNode ? itemNode->parent() : 0);

    if (!parentNode || parentNode == m_bookmarksManager->bookmarks())

        return QModelIndex();

    // get the parent's row

    BookmarkNode *grandParentNode = parentNode->parent();

    int parentRow = grandParentNode->children().indexOf(parentNode);

    Q_ASSERT(parentRow >= 0);

    return createIndex(parentRow, 0, parentNode);

}

bool BookmarksModel::hasChildren(const QModelIndex &parent) const

{