path: root/src/settingsdialogplugins.cpp

#include "settingsdialogplugins.h"
#include "ui_settingsdialog.h"
#include "noeditdelegate.h"
#include <iplugin.h>

#include "organizercore.h"
#include "plugincontainer.h"

using namespace MOBase;

PluginsSettingsTab::PluginsSettingsTab(Settings& s, PluginContainer* pluginContainer, SettingsDialog& d)
  : SettingsTab(s, d), m_pluginContainer(pluginContainer)
{
  ui->pluginSettingsList->setStyleSheet("QTreeWidget::item {padding-right: 10px;}");

  // Create top-level tree widget:
  QStringList pluginInterfaces = m_pluginContainer->pluginInterfaces();
  pluginInterfaces.sort(Qt::CaseInsensitive);
  std::map<QString, QTreeWidgetItem*> topItems;
  for (QString interfaceName : pluginInterfaces) {
    auto* item = new QTreeWidgetItem(ui->pluginsList, { interfaceName });
    item->setFlags(item->flags() & ~Qt::ItemIsSelectable);
    auto font = item->font(0);
    font.setBold(true);
    item->setFont(0, font);
    topItems[interfaceName] = item;
    item->setExpanded(true);
  }
  ui->pluginsList->setHeaderHidden(true);

  // display plugin settings
  QSet<QString> handledNames;
  for (IPlugin* plugin : settings().plugins().plugins()) {
    if (handledNames.contains(plugin->name())) {
      continue;
    }
    if (!m_filter.matches([plugin](const QRegularExpression& regex) {
      return regex.match(plugin->localizedName()).hasMatch();
      })) {
      continue;
    }
    QTreeWidgetItem* listItem = new QTreeWidgetItem(
      topItems.at(m_pluginContainer->topImplementedInterface(plugin)));
    listItem->setData(0, Qt::DisplayRole, plugin->localizedName());
    listItem->setData(0, ROLE_PLUGIN, QVariant::fromValue((void*)plugin));
    listItem->setData(0, ROLE_SETTINGS, settings().plugins().settings(plugin->name()));
    listItem->setData(0, ROLE_DESCRIPTIONS, settings().plugins().descriptions(plugin->name()));

    handledNames.insert(plugin->name());
  }

  for (auto& [k, item] : topItems) {
    if (item->childCount() == 0) {
      item->setHidden(true);
    }
  }

  ui->pluginsList->sortByColumn(0, Qt::AscendingOrder);

  // display plugin blacklist
  for (const QString &pluginName : settings().plugins().blacklist()) {
    ui->pluginBlacklist->addItem(pluginName);
  }

  m_filter.setEdit(ui->pluginFilterEdit);

  QObject::connect(
    ui->pluginsList, &QTreeWidget::currentItemChanged,
    [&](auto* current, auto* previous) { on_pluginsList_currentItemChanged(current, previous); });
  QObject::connect(
    ui->enabledCheckbox, &QCheckBox::clicked,
    [&](bool checked) { on_checkboxEnabled_clicked(checked); });

  QShortcut *delShortcut = new QShortcut(
    QKeySequence(Qt::Key_Delete), ui->pluginBlacklist);
  QObject::connect(delShortcut, &QShortcut::activated, &dialog(), [&] { deleteBlacklistItem(); });
  QObject::connect(&m_filter, &FilterWidget::changed, [&] { filterPluginList(); });

  updateListItems();
  filterPluginList();
}

void PluginsSettingsTab::updateListItems()
{
  for (auto i = 0; i < ui->pluginsList->topLevelItemCount(); ++i) {
    auto* topLevelItem = ui->pluginsList->topLevelItem(i);
    for (auto j = 0; j < topLevelItem->childCount(); ++j) {
      auto* item = topLevelItem->child(j);
      auto* plugin = this->plugin(item);

      bool inactive = !m_pluginContainer->implementInterface<IPluginGame>(plugin)
        && !m_pluginContainer->isEnabled(plugin);
      // TODO: Better display.
    }
  }

}

void PluginsSettingsTab::filterPluginList()
{
  QTreeWidgetItem* firstNotHidden = nullptr;

  for (auto i = 0; i < ui->pluginsList->topLevelItemCount(); ++i) {
    auto* topLevelItem = ui->pluginsList->topLevelItem(i);

    bool found = false;
    for (auto j = 0; j < topLevelItem->childCount(); ++j) {
      auto* item = topLevelItem->child(j);
      auto* plugin = this->plugin(item);

      if (m_filter.matches([plugin](const QRegularExpression& regex) {
        return regex.match(plugin->localizedName()).hasMatch();
        })) {
        found = true;
        item->setHidden(false);

        if (firstNotHidden == nullptr) {
          firstNotHidden = item;
        }
      }
      else {
        item->setHidden(true);
      }
    }

    topLevelItem->setHidden(!found);
  }

  // Unselect item if hidden:
  auto selectedItems = ui->pluginsList->selectedItems();
  if (!selectedItems.isEmpty() && selectedItems[0]->isHidden()) {
    selectedItems[0]->setSelected(false);

    if (firstNotHidden) {
      firstNotHidden->setSelected(true);
    }
  }

}

IPlugin* PluginsSettingsTab::plugin(QTreeWidgetItem* pluginItem) const
{
  return static_cast<IPlugin*>(qvariant_cast<void*>(pluginItem->data(0, ROLE_PLUGIN)));
}

void PluginsSettingsTab::update()
{
  // transfer plugin settings to in-memory structure
  for (int i = 0; i < ui->pluginsList->topLevelItemCount(); ++i) {
    auto *topLevelItem = ui->pluginsList->topLevelItem(i);
    for (int j = 0; j < topLevelItem->childCount(); ++j) {
      auto* item = topLevelItem->child(j);
      settings().plugins().setSettings(
        plugin(item)->name(), item->data(0, ROLE_SETTINGS).toMap());
    }
  }

  // set plugin blacklist
  QStringList names;
  for (QListWidgetItem *item : ui->pluginBlacklist->findItems("*", Qt::MatchWildcard)) {
    names.push_back(item->text());
  }

  settings().plugins().setBlacklist(names);

  settings().plugins().save();
}

void PluginsSettingsTab::closing()
{
  storeSettings(ui->pluginsList->currentItem());
}

void PluginsSettingsTab::on_checkboxEnabled_clicked(bool checked)
{
  // Retrieve the plugin:
  auto *item = ui->pluginsList->currentItem();
  if (!item || !item->data(0, ROLE_PLUGIN).isValid()) {
    return;
  }
  IPlugin* plugin = this->plugin(item);
  const auto& requirements = m_pluginContainer->requirements(plugin);

  // User wants to enable:
  if (checked) {
    auto problems = requirements.problems();
    if (!problems.empty()) {
      QStringList descriptions;
      for (auto& problem : problems) {
        descriptions.append(problem.description());
      }
      QMessageBox::warning(
        parentWidget(), QObject::tr("Cannot enable plugin"),
        QObject::tr("<p>This plugin cannot be enabled:<p><ul>%1</ul>")
        .arg("<li>" + descriptions.join("</li><li>") + "</li>"), QMessageBox::Ok);
      ui->enabledCheckbox->setChecked(false);
      return;
    }

    m_pluginContainer->setEnabled(plugin, true, false);
  }
  else {
    // Custom check for proxy + current game:
    if (m_pluginContainer->implementInterface<IPluginProxy>(plugin)) {
      auto* game = m_pluginContainer->managedGame();
      if (m_pluginContainer->requirements(game).proxy() == plugin) {
        QMessageBox::warning(
          parentWidget(), QObject::tr("Cannot disable plugin"),
          QObject::tr("This plugin is used by the current game plugin and cannot disabled."), QMessageBox::Ok);
          ui->enabledCheckbox->setChecked(true);
          return;
      }
    }

    // Check if the plugins is required for other plugins:
    auto requiredFor = requirements.requiredFor();
    if (!requiredFor.empty()) {
      QStringList pluginNames;
      for (auto& p : requiredFor) {
        pluginNames.append(p->localizedName());
      }
      pluginNames.sort();
      QString message = QObject::tr(
        "<p>Disabling this plugin will also disable the following plugins:</p><ul>%1</ul><p>Do you want to continue?</p>")
        .arg("<li>" + pluginNames.join("</li><li>") + "</li>");
      if (QMessageBox::warning(
        parentWidget(), QObject::tr("Really disable plugin?"), message,
        QMessageBox::Yes | QMessageBox::No) == QMessageBox::No) {
        ui->enabledCheckbox->setChecked(true);
        return;
      }
    }
    m_pluginContainer->setEnabled(plugin, false, true);
  }

  updateListItems();
}

void PluginsSettingsTab::on_pluginsList_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
  storeSettings(previous);

  if (!current->data(0, ROLE_PLUGIN).isValid()) {
    return;
  }

  ui->pluginSettingsList->clear();
  IPlugin* plugin = this->plugin(current);
  ui->authorLabel->setText(plugin->author());
  ui->versionLabel->setText(plugin->version().canonicalString());
  ui->descriptionLabel->setText(plugin->description());

  ui->enabledCheckbox->setVisible(
    !m_pluginContainer->implementInterface<MOBase::IPluginGame>(plugin));
  ui->enabledCheckbox->setChecked(m_pluginContainer->isEnabled(plugin));

  QVariantMap settings = current->data(0, ROLE_SETTINGS).toMap();
  QVariantMap descriptions = current->data(0, ROLE_DESCRIPTIONS).toMap();
  ui->pluginSettingsList->setEnabled(settings.count() != 0);
  for (auto iter = settings.begin(); iter != settings.end(); ++iter) {
    QTreeWidgetItem *newItem = new QTreeWidgetItem(QStringList(iter.key()));
    QVariant value = *iter;
    QString description;
    {
      auto descriptionIter = descriptions.find(iter.key());
      if (descriptionIter != descriptions.end()) {
        description = descriptionIter->toString();
      }
    }

    ui->pluginSettingsList->setItemDelegateForColumn(0, new NoEditDelegate());
    newItem->setData(1, Qt::DisplayRole, value);
    newItem->setData(1, Qt::EditRole, value);
    newItem->setToolTip(1, description);

    newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
    ui->pluginSettingsList->addTopLevelItem(newItem);
  }

  ui->pluginSettingsList->resizeColumnToContents(0);
  ui->pluginSettingsList->resizeColumnToContents(1);
}

void PluginsSettingsTab::deleteBlacklistItem()
{
  ui->pluginBlacklist->takeItem(ui->pluginBlacklist->currentIndex().row());
}

void PluginsSettingsTab::storeSettings(QTreeWidgetItem *pluginItem)
{
  if (pluginItem != nullptr && pluginItem->data(0, ROLE_PLUGIN).isValid()) {
    QVariantMap settings = pluginItem->data(0, ROLE_SETTINGS).toMap();

    for (int i = 0; i < ui->pluginSettingsList->topLevelItemCount(); ++i) {
      const QTreeWidgetItem *item = ui->pluginSettingsList->topLevelItem(i);
      settings[item->text(0)] = item->data(1, Qt::DisplayRole);
    }

    pluginItem->setData(0, ROLE_SETTINGS, settings);
  }
}