path: root/src/src/savestab.cpp

#include "savestab.h"
#include "activatemodsdialog.h"
#include "organizercore.h"
#include "ui_mainwindow.h"
#include <iplugingame.h>
#include <isavegameinfowidget.h>
#include <localsavegames.h>
#include <new>
#include <report.h>

#include <QFile>
#include <QTextStream>

using namespace MOBase;

namespace
{
bool g_disableSaveTooltipsAfterOOM = false;

// Read a value from a Bethesda-style INI file without QSettings.
// QSettings::IniFormat interprets backslashes as line continuations,
// which corrupts values like "sLocalSavePath=__MO_Saves\".
QString readIniValueDirect(const QString& iniFile, const QString& section,
                           const QString& key)
{
  QFile file(iniFile);
  if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
    return {};
  }

  const QString sectionHeader = "[" + section + "]";
  QTextStream in(&file);
  bool inSection = false;

  while (!in.atEnd()) {
    QString line = in.readLine().trimmed();
    if (line.startsWith('[') && line.endsWith(']')) {
      if (inSection)
        break;
      if (line.compare(sectionHeader, Qt::CaseInsensitive) == 0)
        inSection = true;
      continue;
    }

    if (inSection && !line.isEmpty() && !line.startsWith(';') &&
        !line.startsWith('#')) {
      int eqPos = line.indexOf('=');
      if (eqPos > 0) {
        QString existingKey = line.left(eqPos).trimmed();
        if (existingKey.compare(key, Qt::CaseInsensitive) == 0) {
          return line.mid(eqPos + 1).trimmed();
        }
      }
    }
  }

  return {};
}

QString sanitizeText(QString in, int maxLen = 200)
{
  for (int i = 0; i < in.size(); ++i) {
    const QChar c = in.at(i);
    // Replace control chars except common whitespace.
    if (c.unicode() < 0x20 && c != QChar('\n') && c != QChar('\r') && c != QChar('\t')) {
      in[i] = QChar('?');
    }
  }

  if (in.size() > maxLen) {
    in.truncate(maxLen);
    in += "...";
  }

  return in;
}

bool isLikelyCorruptSaveText(QString const& in)
{
  if (in.trimmed().isEmpty()) {
    return true;
  }

  int suspicious = 0;
  for (const QChar c : in) {
    if (c.unicode() == 0xFFFD || c.isNull() ||
        (!c.isPrint() && !c.isSpace())) {
      ++suspicious;
    }
  }

  return suspicious > (in.size() / 8);
}
}  // namespace

SavesTab::SavesTab(QWidget* window, OrganizerCore& core, Ui::MainWindow* mwui)
    : m_window(window), m_core(core), m_CurrentSaveView(nullptr),
      ui{.mainTabs=mwui->tabWidget, .tab=mwui->savesTab, .list=mwui->savegameList}
{
  m_SavesWatcherTimer.setSingleShot(true);
  m_SavesWatcherTimer.setInterval(500);

  ui.list->installEventFilter(this);
  ui.list->setMouseTracking(true);

  connect(&m_SavesWatcher, &QFileSystemWatcher::directoryChanged, [&] {
    m_SavesWatcherTimer.start();
  });

  connect(&m_SavesWatcherTimer, &QTimer::timeout, [&] {
    refreshSavesIfOpen();
  });

  connect(ui.list, &QWidget::customContextMenuRequested, [&](auto pos) {
    onContextMenu(pos);
  });

  connect(ui.list, &QTreeWidget::itemEntered, [&](auto* item) {
    saveSelectionChanged(item);
  });
}

bool SavesTab::eventFilter(QObject* object, QEvent* e)
{
  if (object == ui.list) {
    if (e->type() == QEvent::Leave || e->type() == QEvent::WindowDeactivate) {
      hideSaveGameInfo();
    } else if (e->type() == QEvent::KeyPress) {
      QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
      if (keyEvent->key() == Qt::Key_Delete) {
        deleteSavegame();
      }
    }
  }

  return false;
}

void SavesTab::displaySaveGameInfo(QTreeWidgetItem* newItem)
{
  if (g_disableSaveTooltipsAfterOOM) {
    return;
  }

  // don't display the widget if the main window doesn't have focus
  //
  // this goes against the standard behaviour for tooltips, which are displayed
  // on hover regardless of focus, but this widget is so large and busy that
  // it's probably better this way
  if (!m_window->isActiveWindow()) {
    return;
  }

  if (m_CurrentSaveView == nullptr) {
    auto info = m_core.gameFeatures().gameFeature<SaveGameInfo>();

    if (info != nullptr) {
      m_CurrentSaveView = info->getSaveGameWidget(m_window);
    }

    if (m_CurrentSaveView == nullptr) {
      return;
    }
  }

  try {
    m_CurrentSaveView->setSave(*m_SaveGames[ui.list->indexOfTopLevelItem(newItem)]);
  } catch (const std::bad_alloc&) {
    g_disableSaveTooltipsAfterOOM = true;
    log::error("insufficient memory while rendering save tooltip for '{}'",
               sanitizeText(newItem ? newItem->text(0) : QString()));
    reportError(QObject::tr("Save tooltip rendering was disabled for this session due "
                            "to low memory while parsing save metadata."));
    hideSaveGameInfo();
    return;
  } catch (const std::exception& e) {
    log::error("failed to render save tooltip: {}", e.what());
    hideSaveGameInfo();
    return;
  }

  QWindow* window = m_CurrentSaveView->window()->windowHandle();
  QRect screenRect;
  if (window == nullptr)
    screenRect = QGuiApplication::primaryScreen()->geometry();
  else
    screenRect = window->screen()->geometry();

  QPoint pos = QCursor::pos();
  if (pos.x() + m_CurrentSaveView->width() > screenRect.right()) {
    pos.rx() -= (m_CurrentSaveView->width() + 2);
  } else {
    pos.rx() += 5;
  }

  if (pos.y() + m_CurrentSaveView->height() > screenRect.bottom()) {
    pos.ry() -= (m_CurrentSaveView->height() + 10);
  } else {
    pos.ry() += 20;
  }
  m_CurrentSaveView->move(pos);

  m_CurrentSaveView->show();
  m_CurrentSaveView->setProperty("displayItem",
                                 QVariant::fromValue(static_cast<void*>(newItem)));
}

void SavesTab::saveSelectionChanged(QTreeWidgetItem* newItem)
{
  if (newItem == nullptr) {
    hideSaveGameInfo();
  } else if (m_CurrentSaveView == nullptr ||
             newItem != m_CurrentSaveView->property("displayItem").value<void*>()) {
    displaySaveGameInfo(newItem);
  }
}

void SavesTab::hideSaveGameInfo()
{
  if (m_CurrentSaveView != nullptr) {
    m_CurrentSaveView->deleteLater();
    m_CurrentSaveView = nullptr;
  }
}

void SavesTab::refreshSavesIfOpen()
{
  if (ui.mainTabs->currentWidget() == ui.tab) {
    refreshSaveList();
  }
}

QDir SavesTab::currentSavesDir() const
{
  // TODO: This code should probably be handled by the game plugins
  QDir savesDir;
  if (m_core.currentProfile()->localSavesEnabled()) {
    savesDir.setPath(m_core.currentProfile()->savePath());
  } else {
    auto iniFiles = m_core.managedGame()->iniFiles();

    if (iniFiles.isEmpty() ||
        m_core.gameFeatures().gameFeature<LocalSavegames>() == nullptr) {
      return m_core.managedGame()->savesDirectory();
    }

    QString iniPath = m_core.currentProfile()->absoluteIniFilePath(iniFiles[0]);

    // Read directly without QSettings — QSettings::IniFormat interprets
    // trailing backslashes as line continuations, corrupting values like
    // "sLocalSavePath=__MO_Saves\".
    QString savePath = readIniValueDirect(iniPath, "General", "sLocalSavePath");
    // Strip trailing path separators (Bethesda INIs use "Saves\" with a
    // trailing backslash that is part of the value, not a continuation).
    while (savePath.endsWith('\\') || savePath.endsWith('/')) {
      savePath.chop(1);
    }
    if (!savePath.isEmpty() &&
        savePath.compare("__MO_Saves", Qt::CaseInsensitive) != 0) {
      savesDir.setPath(
          m_core.managedGame()->documentsDirectory().absoluteFilePath(savePath));
    } else {
      savesDir = m_core.managedGame()->savesDirectory();
    }
  }

  return savesDir;
}

void SavesTab::startMonitorSaves()
{
  stopMonitorSaves();

  QDir savesDir = currentSavesDir();

  m_SavesWatcher.addPath(savesDir.absolutePath());
}

void SavesTab::stopMonitorSaves()
{
  if (!m_SavesWatcher.directories().empty()) {
    m_SavesWatcher.removePaths(m_SavesWatcher.directories());
  }
}

void SavesTab::refreshSaveList()
{
  TimeThis tt("MainWindow::refreshSaveList()");

  startMonitorSaves();  // re-starts monitoring

  try {
    QDir savesDir = currentSavesDir();
    MOBase::log::debug("reading save games from {}", savesDir.absolutePath());
    m_SaveGames = m_core.managedGame()->listSaves(savesDir);
    std::sort(m_SaveGames.begin(), m_SaveGames.end(),
              [](auto const& lhs, auto const& rhs) {
                return lhs->getCreationTime() > rhs->getCreationTime();
              });

    ui.list->clear();
    for (auto& save : m_SaveGames) {
      auto relpath = savesDir.relativeFilePath(save->getFilepath());
      const auto rawName = save->getName();
      auto display       = sanitizeText(rawName, 300);
      if (display.trimmed().isEmpty() || isLikelyCorruptSaveText(rawName)) {
        display = sanitizeText(QFileInfo(save->getFilepath()).completeBaseName(), 300);
      }
      ui.list->addTopLevelItem(new QTreeWidgetItem(ui.list, {display, relpath}));
    }
  } catch (std::exception& e) {
    // listSaves() can throw
    log::error("{}", e.what());
  }
}

void SavesTab::deleteSavegame()
{
  auto info = m_core.gameFeatures().gameFeature<SaveGameInfo>();

  QString savesMsgLabel;
  QStringList deleteFiles;

  int count = 0;

  for (const QModelIndex& idx : ui.list->selectionModel()->selectedRows()) {

    auto& saveGame = m_SaveGames[idx.row()];

    if (count < 10) {
      savesMsgLabel +=
          "<li>" + QFileInfo(saveGame->getFilepath()).completeBaseName() + "</li>";
    }
    ++count;

    deleteFiles += saveGame->allFiles();
  }

  if (count > 10) {
    savesMsgLabel += "<li><i>... " + tr("%1 more").arg(count - 10) + "</i></li>";
  }

  if (QMessageBox::question(
          m_window, tr("Confirm"),
          tr("Are you sure you want to remove the following %n save(s)?<br>"
             "<ul>%1</ul><br>"
             "Removed saves will be sent to the Recycle Bin.",
             "", count)
              .arg(savesMsgLabel),
          QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
    shellDelete(deleteFiles, true);  // recycle bin delete.
    refreshSaveList();
  }
}

void SavesTab::onContextMenu(const QPoint& pos)
{
  QItemSelectionModel* selection = ui.list->selectionModel();

  if (!selection->hasSelection()) {
    return;
  }

  QMenu menu;

  auto info = m_core.gameFeatures().gameFeature<SaveGameInfo>();
  if (info != nullptr) {
    QAction* action = menu.addAction(tr("Fix enabled mods..."));
    action->setEnabled(false);
    if (selection->selectedRows().count() == 1) {
      auto& save = m_SaveGames[selection->selectedRows()[0].row()];
      SaveGameInfo::MissingAssets missing = info->getMissingAssets(*save);
      if (!missing.empty()) {
        connect(action, &QAction::triggered, this, [this, missing] {
          fixMods(missing);
        });
        action->setEnabled(true);
      }
    }
  }

  QString deleteMenuLabel =
      tr("Delete %n save(s)", "", selection->selectedRows().count());
  menu.addAction(deleteMenuLabel, [&] {
    deleteSavegame();
  });

  menu.addAction(tr("Open in Explorer..."), [&] {
    openInExplorer();
  });

  menu.exec(ui.list->viewport()->mapToGlobal(pos));
}

void SavesTab::fixMods(SaveGameInfo::MissingAssets const& missingAssets)
{
  ActivateModsDialog dialog(missingAssets, m_window);
  if (dialog.exec() == QDialog::Accepted) {
    // activate the required mods, then enable all esps
    std::set<QString> modsToActivate = dialog.getModsToActivate();
    for (std::set<QString>::iterator iter = modsToActivate.begin();
         iter != modsToActivate.end(); ++iter) {
      if ((*iter != "<data>") && (*iter != "<overwrite>")) {
        unsigned int modIndex = ModInfo::getIndex(*iter);
        m_core.currentProfile()->setModEnabled(modIndex, true);
      }
    }

    m_core.currentProfile()->writeModlist();
    m_core.refreshLists();

    std::set<QString> espsToActivate = dialog.getESPsToActivate();
    for (std::set<QString>::iterator iter = espsToActivate.begin();
         iter != espsToActivate.end(); ++iter) {
      m_core.pluginList()->enableESP(*iter);
    }

    m_core.saveCurrentLists();
  }
}

void SavesTab::openInExplorer()
{
  auto info = m_core.gameFeatures().gameFeature<SaveGameInfo>();

  const auto sel = ui.list->selectionModel()->selectedRows();
  if (sel.empty()) {
    return;
  }

  auto& saveGame = m_SaveGames[sel[0].row()];
  shell::Explore(saveGame->getFilepath());
}