/* ============================================================
 *     The rekonq project
 * ============================================================
 * SPDX-License-Identifier: GPL-2.0-or-later
 * Copyright (C) 2008-2012 by Andrea Diamantini <adjam7 at gmail dot com>
 * Copyright (C) 2009 by Paweł Prażak <pawelprazak at gmail dot com>
 * Copyright (C) 2009-2010 by Lionel Chauvin <megabigbug@yahoo.fr>
 * Copyright (C) 2010 by Yoann Laissus <yoann dot laissus at gmail dot com>
 * SPDX-License-Identifier: GPL-3.0-only
 * Copyright (C) 2022 aqua <aqua@iserlohn-fortress.net>
 * ============================================================
 * Description: rekonq bookmarks system interface
 * ============================================================ */

#include "bookmarkmanager.hpp"
#include <QCoreApplication>
#include <QFile>
#include <QMenu>

// ----------------------------------------------------------------------------------------------
// Constructor and Destructor

BookmarkManager::BookmarkManager(const QString &bookmarksFile, QObject *parent)
    : QObject(parent), m_model(new BookmarkModel(this))
{
  if (!bookmarksFile.isEmpty()) {
    QFile bf(bookmarksFile);
    if (bf.open(QIODevice::ReadOnly | QIODevice::Text)) {
      m_errors += m_model->load(&bf);
      bf.close();
    }
    else
      m_errors +=
          tr("%1 Bookmarks file '%2' cannot be opened: %3").arg(__PRETTY_FUNCTION__, bookmarksFile, bf.errorString());
  }

  // connect(m_manager, SIGNAL(changed(QString, QString)), this, SLOT(slotBookmarksChanged()));

  // bookmarks loading
  // connect(this, SIGNAL(openUrl(KUrl, Rekonq::OpenType)), rApp, SLOT(loadUrl(KUrl, Rekonq::OpenType)));
}

BookmarkManager::~BookmarkManager() { delete m_model; }

// ----------------------------------------------------------------------------------------------
/*
QList<Bookmark> BookmarkManager::find(const QString &text)
{
  BookmarkGroup list;
  auto *root = m_model->item();
  Q_CHECK_PTR(root);


  KBookmarkGroup root = rootGroup();
  if (!root.isNull())
    for (KBookmark bookmark = root.first(); !bookmark.isNull(); bookmark = root.next(bookmark))
      find(&list, bookmark, text);

  return list;
}

KBookmark BookmarkManager::bookmarkForUrl(const KUrl &url)
{
  KBookmarkGroup root = rootGroup();
  if (root.isNull()) return KBookmark();

  return bookmarkForUrl(root, url);
}

void BookmarkManager::slotBookmarksChanged()
{
  Q_FOREACH (BookmarkToolBar *bookmarkToolBar, m_bookmarkToolBars) {
    if (bookmarkToolBar) {
      bookmarkToolBar->clear();
      fillBookmarkBar(bookmarkToolBar);
    }
  }

  // NOTE with this signal, we should (eventual) update about:bookmarks page...
  emit bookmarksUpdated();
}

KBookmark BookmarkManager::bookmarkCurrentPage(const KBookmark &bookmark)
{
  return m_owner->bookmarkCurrentPage(bookmark);
}

void BookmarkManager::fillBookmarkBar(BookmarkToolBar *toolBar)
{
  KBookmarkGroup root = m_manager->toolbar();
  if (root.isNull()) return;

  for (KBookmark bookmark = root.first(); !bookmark.isNull(); bookmark = root.next(bookmark)) {
    if (bookmark.isGroup()) {
      KBookmarkActionMenu *menuAction = new KBookmarkActionMenu(bookmark.toGroup(), toolBar);
      menuAction->setDelayed(false);
      BookmarkMenu *bMenu = new BookmarkMenu(m_manager, m_owner, menuAction->menu(), bookmark.address());
      bMenu->setParent(menuAction->menu());

      connect(menuAction->menu(), SIGNAL(aboutToShow()), toolBar, SLOT(menuDisplayed()));
      connect(menuAction->menu(), SIGNAL(aboutToHide()), toolBar, SLOT(menuHidden()));

      toolBar->addAction(menuAction);
      toolBar->widgetForAction(menuAction)->installEventFilter(toolBar);
    }
    else if (bookmark.isSeparator()) {
      toolBar->addSeparator();
    }
    else {
      KBookmarkAction *action = new KBookmarkAction(bookmark, m_owner, toolBar);
      action->setIcon(IconManager::self()->iconForUrl(KUrl(bookmark.url())));
      toolBar->addAction(action);
      toolBar->widgetForAction(action)->installEventFilter(toolBar);
    }
  }
}

void BookmarkManager::find(QList<KBookmark> *list, const KBookmark &bookmark, const QString &text)
{
  if (bookmark.isGroup()) {
    KBookmarkGroup group = bookmark.toGroup();
    for (KBookmark bm = group.first(); !bm.isNull(); bm = group.next(bm)) find(list, bm, text);
  }
  else {
    QStringList words = text.split(' ');
    bool matches = true;
    Q_FOREACH (const QString &word, words) {
      if (!bookmark.url().url().contains(word, Qt::CaseInsensitive) &&
          !bookmark.fullText().contains(word, Qt::CaseInsensitive)) {
        matches = false;
        break;
      }
    }
    if (matches) *list << bookmark;
  }
}

KBookmark BookmarkManager::bookmarkForUrl(const KBookmark &bookmark, const KUrl &url)
{
  KBookmark found;

  if (bookmark.isGroup()) {
    KBookmarkGroup group = bookmark.toGroup();
    KBookmark bookmark = group.first();

    while (!bookmark.isNull() && found.isNull()) {
      found = bookmarkForUrl(bookmark, url);
      bookmark = group.next(bookmark);
    }
  }
  else if (!bookmark.isSeparator() && bookmark.url() == url) {
    found = bookmark;
  }

  return found;
}

void BookmarkManager::slotEditBookmarks() { m_manager->slotEditBookmarks(); }

void BookmarkManager::openFolderInTabs(const BookmarkGroup &group) {
  for(const auto &bookmark : group) {
    // TODO emit openUrl
  }
}

KActionMenu *BookmarkManager::bookmarkActionMenu(QWidget *parent)
{
  auto *menu = new QMenu(parent);
  KActionMenu *bookmarkActionMenu = new KActionMenu(menu);
  bookmarkActionMenu->setMenu(menu);
  bookmarkActionMenu->setText(tr("&Bookmarks"));
  BookmarkMenu *bMenu = new BookmarkMenu(m_manager, m_owner, menu, m_actionCollection);
  bMenu->setParent(menu);

  return bookmarkActionMenu;
}
*/