/*

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

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include <QtCore/QDir>

#include <QtCore/QFile>

#include <QtGui/QIcon>

#include <QtGui>

#include <QtCore/QDebug>

#include <QtCore/QUrl>

#include <QString>

#include "actionjsobject.h"

#include "BookmarksManager_p.h"

#include "BookmarksManager.h"

//#include "wrtsettings.h"

#include "bedrockprovisioning.h"

#include "bookmarks.h"

#include <browsercontentdll.h>

#include "xbel.h"

#include "webpagecontroller.h"

#include "wrtbrowsercontainer.h"

namespace WRT {

BookmarksManagerPrivate::BookmarksManagerPrivate(BookmarksManager * mgr, QWidget *parent) :

    q(mgr),

    m_connectedToBookmarks(false),

    m_maxUrls(10) // TODO: read from settings

{

    m_import = false;

    QFileInfo dbFile("browserContent.db");

    if (dbFile.exists()){

      m_import = false;

    }

    else {

      m_import = true;

    }

    m_bookmarkSession=new BrowserContent("Bedrock");

    if (m_bookmarkSession) {

        m_connectedToBookmarks = true;

    } else {

        qDebug() << "BookmarksManagerPrivate: Failed to connect to bookmarks";

    }

    m_actionsParent = new QObject(mgr);

    m_actionsParent->setObjectName("actions");

    m_actionClearHistory = new QAction("clearHistory", m_actionsParent);

    m_actionClearJSO  = new ActionJSObject(m_actionsParent, m_actionClearHistory);

    m_actionClearHistory->setObjectName("clearHistory");

}

BookmarksManagerPrivate::~BookmarksManagerPrivate()

{

    delete m_bookmarkSession;

    delete m_actionClearHistory;

    delete m_actionClearJSO;

}

/*!

 * \class BookmarksManager

 *

 * This class is responsible for managing bookmarks, This class could be used 

 * mainly for Creating, adding bookmarks, adding recent history items, deleting 

 * and editing bookmarks.

 *

 */

/*!

 * Basic constructor

 * @param parent : parent widget (Defaulted to NULL ) if not specified

 */

BookmarksManager::BookmarksManager(QWidget *parent) :

    d(new BookmarksManagerPrivate(this, parent))

{

    if (d->m_import)

       importNativeBookmarks();

    m_isBookmarkDbreadRequired=true;

    //connect(d->m_actionClearHistory, SIGNAL(triggered()), this, SIGNAL(historyCleared()));

    connect(d->m_actionClearHistory, SIGNAL(triggered()), this, SIGNAL(confirmHistoryClear()));

}

/*

void BookmarksManager::actionClearHistory()

{

    emit confirmClearHistory();

}

*/

BookmarksManager::~BookmarksManager()

{

    disconnect(d->m_actionClearHistory, SIGNAL(triggered()), this, SIGNAL(historyCleared()));

    delete d;

}

BookmarksManager* BookmarksManager::getSingleton()

 {

    static BookmarksManager* singleton = 0;

    if(!singleton){

           singleton = new BookmarksManager;

           singleton->setObjectName("bookmarksManager");

    }

    //assert(singleton);

    return singleton;    

 }

}

/*!

 * Import the bookmarks grom Native Browser

 * Ignores errors (just exists)

 */

void BookmarksManager::importNativeBookmarks()

{

#ifdef Q_OS_SYMBIAN

      int error = ::MainImport();

      if(error)

          return;

    startNativeBookmarksParsing();

    QString fileName = "c:/data/bookmarks.txt.xml";

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

    }

    int bookmarkCount = importRootNode->children().count() - 1;

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

        BookmarkNode *node = importRootNode->children()[i];

        if (node->type() == BookmarkNode::Bookmark) 

            addBookmark(node->title,node->url,0);

    } 

#endif

}

QString BookmarksManager::getBookmarksJSON()

    {

    if(m_isBookmarkDbreadRequired==true)

        {

    m_isBookmarkDbreadRequired=false;

       }

    return m_bookmakrData;

    }

    // If the URL is relative, add http in front

    // so that qt doesn't make it absolute using the

    // local file path

    if (!url.contains("://")) {

        if (!url.startsWith("www", Qt::CaseInsensitive)) {

            updatedUrl.prepend("http://www.");

        } else {

           updatedUrl.prepend("http://");

        }

    }

    //Setting title as url string if title is not available

    BookmarkLeaf* leaf=new BookmarkLeaf();

    leaf->setTitle(updatedTitle);

    leaf->setUrl(updatedUrl);

    //leaf->setDate(bookmark->date);

    leaf->setTag("unknown");

    leaf->setIndex(index);

    emit bookmarkEntryAdded(updatedTitle,updatedUrl);

    delete leaf;

    m_isBookmarkDbreadRequired=true;

    return ErrNone;

    }

    delete leaf;

    return ErrGeneral;

}

void BookmarksManager::deleteBookmark(QString title)

{

    m_isBookmarkDbreadRequired=true;

}

void BookmarksManager::clearBookmarks()

{

    d->m_bookmarkSession->clearBookmarks();

    m_isBookmarkDbreadRequired=true;

}

int BookmarksManager::reorderBokmarks(QString title,int new_index)

{

    d->m_bookmarkSession->reorderBokmarks(title,new_index);

    m_isBookmarkDbreadRequired=true;

    return ErrNone;    

}

int BookmarksManager::modifyBookmark(QString orgTitle, QString newTitle, QString newUrl)

{

    QString updatedTitle = newTitle;

    //Setting title as url string if title is not available

    if(newUrl.isEmpty())

        return ErrBookmarkUrlEmpty;

    QList<BookmarkLeaf*> nodes;

    for (int iter = 0 ; iter < nodes.count() ; ++iter)   {

      }

    }

    qDeleteAll(nodes);

    nodes.clear();

  //Setting title as url string if title is not available

    if(newTitle.isEmpty())

        m_isBookmarkDbreadRequired=true;

        return ErrNone;

    }

    return ErrGeneral;

}

void BookmarksManager::launchEditBookmark(QString title,QString url)

{

    emit launchBookmarkEditDailog(title,url);

}

QString BookmarksManager::getHistoryFoldersJSON(QString folderName)

    {

    bool flag = true;

    QString historyFolders = "[";

        {

        //check for folder nodes

        historyFolders.append("\"");

        historyFolders.append("\"");

        if (i != 0)

            historyFolders.append(",");

        if (flag)

            {

                {

                d->m_actionClearHistory->setEnabled(true);

                flag=false;

                }

            }

        }

     if (flag)

        {

        d->m_actionClearHistory->setEnabled(false);

        }

    historyFolders.append("]");

    if (folderName == "")

        {

        return historyFolders;

        }

    else

        {

        }

    }

/*!

 * Add the  node to the folder in proxy model. If the folder doesnt exist in proxy, create

 * the folder  and add the node to it

 */

/*!

 * Add to recent urls

 * @param url: url to be added to recent url list

 * @param title: title for this item in recent url list

 * @param icon: icon to be added for this item in recent url list

 */

Q_DECL_EXPORT void BookmarksManager::addHistory(const QString &url, const QString &title)

{

    //Check for a valid history entry

    if (url.isEmpty() || title.isEmpty())

        return;

    bool enabled = (bool) BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning()->valueAsInt("SaveHistory");

    if(!enabled)

      return;

    QDateTime currentDateTime = QDateTime::currentDateTime();

    HistoryLeaf* leaf=new HistoryLeaf();

    leaf->setTitle(title);

    leaf->setUrl(url);

    leaf->setDate(currentDateTime.date());

    leaf->setLastVisited(currentDateTime.time());

    if (d->m_connectedToBookmarks){

          d->m_actionClearHistory->setEnabled(true);

        }

    }

    delete leaf;

}

/*!

 * Add to recent urls

 * @param url: url to be added to recent url list

 * @param title: title for this item in recent url list

 * @param icon: icon to be added for this item in recent url list

 */

void BookmarksManager::addHistory(const QUrl &url, const QString &title)

{

    addHistory(url.toString(), title);

}

/*!

 * delete recent urls

 * clears all the recent url list.

 */

void BookmarksManager::clearHistory()

{

    if (d->m_connectedToBookmarks) {

        d->m_bookmarkSession->clearHistory();

    }

    d->m_actionClearHistory->setEnabled(false);

    emit historyCleared();

}

QAction * BookmarksManager::getActionClearHistory()

{

    return d->m_actionClearHistory;

}

int BookmarksManager::getPageRank(const QString &url)

{

    if (url.isNull())

        return 0;

    int rank = 0;

      //Update rank if there is a history for this URL.

           rank++;

    }

    return rank;

}