path: root/src/createinstancedialog.cpp

#include "createinstancedialog.h"
#include "ui_createinstancedialog.h"
#include "instancemanager.h"
#include "plugincontainer.h"
#include "shared/appconfig.h"
#include <report.h>
#include <iplugingame.h>

namespace cid
{

class PathChecker
{
public:
  PathChecker(QLabel* existsLabel, QLabel* invalidLabel)
    : m_exists(existsLabel), m_invalid(invalidLabel)
  {
    m_existsOriginal = m_exists->text();
    m_invalidOriginal = m_invalid->text();
  }

  QString sanitizeFileName(const QString& name) const
  {
    QString new_name = name;

    // Restrict the allowed characters
    new_name = new_name.remove(QRegExp("[^A-Za-z0-9 _=+;!@#$%^'\\-\\.\\[\\]\\{\\}\\(\\)]"));

    // Don't end in spaces and periods
    new_name = new_name.remove(QRegExp("\\.*$"));
    new_name = new_name.remove(QRegExp(" *$"));

    // Recurse until stuff stops changing
    if (new_name != name) {
      return sanitizeFileName(new_name);
    }

    return new_name;
  }

  // same thing as above, but allows path separators and colons
  //
  QString sanitizePath(const QString& path) const
  {
    QString new_name = path;

    // Restrict the allowed characters
    new_name = new_name.remove(QRegExp("[^\\\\\\/A-Za-z0-9 _=+;!@#$%^:'\\-\\.\\[\\]\\{\\}\\(\\)]"));

    // Don't end in spaces and periods
    new_name = new_name.remove(QRegExp("\\.*$"));
    new_name = new_name.remove(QRegExp(" *$"));

    // Recurse until stuff stops changing
    if (new_name != path) {
      return sanitizeFileName(new_name);
    }

    return new_name;
  }

  bool checkName(QString parentDir, QString name) const
  {
    bool exists = false;
    bool invalid = false;
    bool empty = false;

    name = name.trimmed();

    if (name.isEmpty()) {
      empty = true;
    } else {
      const QString sanitized = sanitizeFileName(name);

      if (name != sanitized) {
        invalid = true;
      } else {
        exists = QDir(parentDir).exists(name);
      }
    }

    bool okay = false;

    if (exists) {
      m_exists->setVisible(true);
      setPossiblePlaceholder(m_exists, m_existsOriginal, QDir(parentDir).filePath(name));
      m_invalid->setVisible(false);
    } else if (invalid) {
      m_exists->setVisible(false);
      m_invalid->setVisible(true);
      setPossiblePlaceholder(m_invalid, m_invalidOriginal, name);
    } else {
      okay = !empty;
      m_exists->setVisible(false);
      m_invalid->setVisible(false);
    }

    return okay;
  }

  bool checkPath(QString path) const
  {
    bool exists = false;
    bool invalid = false;
    bool empty = false;

    path = path.trimmed();

    if (path.isEmpty()) {
      empty = true;
    } else {
      const QString sanitized = sanitizePath(path);

      if (path != sanitized) {
        invalid = true;
      } else {
        exists = QDir(path).exists();
      }
    }

    bool okay = false;

    if (exists) {
      m_exists->setVisible(true);
      setPossiblePlaceholder(m_exists, m_existsOriginal, path);
      m_invalid->setVisible(false);
    } else if (invalid) {
      m_exists->setVisible(false);
      m_invalid->setVisible(true);
      setPossiblePlaceholder(m_invalid, m_invalidOriginal, path);
    } else {
      okay = !empty;
      m_exists->setVisible(false);
      m_invalid->setVisible(false);
    }

    return okay;
  }

private:
  QLabel* m_exists;
  QString m_existsOriginal;

  QLabel* m_invalid;
  QString m_invalidOriginal;

  void setPossiblePlaceholder(
    QLabel* label, const QString& s, const QString& arg) const
  {
    if (label->text().contains("%1")) {
      label->setText(s.arg(arg));
    }
  }
};


class Page
{
public:
  Page(CreateInstanceDialog& dlg)
    : ui(dlg.getUI()), m_dlg(dlg), m_pc(dlg.pluginContainer())
  {
  }

  virtual bool ready() const
  {
    return true;
  }

  virtual bool skip() const
  {
    // no-op
    return false;
  }

  virtual void activated()
  {
    // no-op
  }

  void updateNavigation()
  {
    m_dlg.updateNavigation();
  }

  void next()
  {
    m_dlg.next();
  }


  virtual CreateInstanceDialog::Types selectedType() const
  {
    // no-op
    return CreateInstanceDialog::NoType;
  }

  virtual MOBase::IPluginGame* selectedGame() const
  {
    // no-op
    return nullptr;
  }

  virtual QString instanceName() const
  {
    // no-op
    return {};
  }

protected:
  Ui::CreateInstanceDialog* ui;
  CreateInstanceDialog& m_dlg;
  const PluginContainer& m_pc;
};


class InfoPage : public Page
{
public:
  InfoPage(CreateInstanceDialog& dlg)
    : Page(dlg)
  {
  }
};


class TypePage : public Page
{
public:
  TypePage(CreateInstanceDialog& dlg)
    : Page(dlg), m_type(CreateInstanceDialog::NoType)
  {
    ui->createGlobal->setDescription(
      ui->createGlobal->description()
        .arg(InstanceManager::instance().instancesPath()));

    ui->createPortable->setDescription(
      ui->createPortable->description()
        .arg(qApp->applicationDirPath()));

    QObject::connect(
      ui->createGlobal, &QAbstractButton::clicked, [&]{ global(); });

    QObject::connect(
      ui->createPortable, &QAbstractButton::clicked, [&]{ portable(); });
  }

  bool ready() const override
  {
    return (m_type != CreateInstanceDialog::NoType);
  }

  CreateInstanceDialog::Types selectedType() const
  {
    return m_type;
  }

  void global()
  {
    m_type = CreateInstanceDialog::Global;

    ui->createGlobal->setChecked(true);
    ui->createPortable->setChecked(false);

    next();
  }

  void portable()
  {
    m_type = CreateInstanceDialog::Portable;

    ui->createGlobal->setChecked(false);
    ui->createPortable->setChecked(true);

    next();
  }

private:
  CreateInstanceDialog::Types m_type;
};


class GamePage : public Page
{
public:
  GamePage(CreateInstanceDialog& dlg)
    : Page(dlg), m_selection(nullptr)
  {
    createGames();
    fillList();

    QObject::connect(ui->showAllGames, &QCheckBox::clicked, [&]{ fillList(); });
  }

  bool ready() const override
  {
    return (m_selection != nullptr);
  }

  MOBase::IPluginGame* selectedGame() const override
  {
    if (!m_selection) {
      return nullptr;
    }

    return m_selection->game;
  }

  void select(MOBase::IPluginGame* game)
  {
    Game* checked = findGame(game);

    if (checked) {
      if (!checked->installed) {
        const auto path = QFileDialog::getExistingDirectory(
          &m_dlg, QObject::tr("Find game installation"));

        if (path.isEmpty()) {
          checked = nullptr;
        } else {
          checked = checkInstallation(path, checked);
        }
      }
    }

    m_selection = checked;
    selectButton(checked);
    updateNavigation();
  }

  void selectCustom()
  {
    const auto path = QFileDialog::getExistingDirectory(
      &m_dlg, QObject::tr("Find game installation"));

    if (path.isEmpty()) {
      selectButton(m_selection);
      return;
    }

    for (auto& g : m_games) {
      if (g->game->looksValid(path)) {
        g->dir = path;
        g->installed = true;
        select(g->game);
        updateButton(g.get());
        return;
      }
    }

    warnUnrecognized(path);
    selectButton(m_selection);
  }

  void warnUnrecognized(const QString& path)
  {
    QString supportedGames;
    for (auto* game : sortedGamePlugins()) {
      supportedGames += "<li>" + game->gameName() + "</li>";
    }

    QMessageBox::warning(&m_dlg,
      QObject::tr("Unrecognized game"),
      QObject::tr(
        "The folder %1 does not seem to contain a game Mod Organizer can "
        "manage.<br><br><b>These are the games that can be managed:</b>"
        "<ul>%2</ul>").arg(path).arg(supportedGames));
  }

private:
  struct Game
  {
    MOBase::IPluginGame* game = nullptr;
    QCommandLinkButton* button = nullptr;
    QString dir;
    bool installed = false;

    Game(MOBase::IPluginGame* g)
      : game(g), installed(g->isInstalled())
    {
      if (installed) {
        dir = game->gameDirectory().path();
      }
    }

    Game(const Game&) = delete;
    Game& operator=(const Game&) = delete;
  };

  std::vector<std::unique_ptr<Game>> m_games;
  Game* m_selection;


  std::vector<MOBase::IPluginGame*> sortedGamePlugins() const
  {
    std::vector<MOBase::IPluginGame*> v;

    for (auto* game : m_pc.plugins<MOBase::IPluginGame>()) {
      v.push_back(game);
    }

    std::sort(v.begin(), v.end(), [](auto* a, auto* b) {
      return (a->gameName() < b->gameName());
    });

    return v;
  }

  Game* findGame(MOBase::IPluginGame* game)
  {
    for (auto& g : m_games) {
      if (g->game == game) {
        return g.get();
      }
    }

    return nullptr;
  }

  void createGames()
  {
    m_games.clear();

    for (auto* game : sortedGamePlugins()) {
      m_games.push_back(std::make_unique<Game>(game));
    }
  }

  void updateButton(Game* g)
  {
    if (!g || !g->button) {
      return;
    }

    g->button->setText(g->game->gameName());

    if (g->installed) {
      g->button->setDescription(g->dir);
    } else {
      g->button->setDescription(QObject::tr("No installation found"));
    }
  }

  void selectButton(Game* g)
  {
    // go through each game, set the button that is for game `g` as active;
    // some button might not exist, which happens when selecting a custom
    // folder for a game that was considered uninstalled

    for (const auto& gg : m_games) {
      if (!g) {
        // nothing should be selected
        if (gg->button) {
          gg->button->setChecked(false);
        }

        continue;
      }

      if (gg->game == g->game) {
        // this is the button that should be selected

        if (!gg->button) {
          // this happens when the button wasn't visible because the game
          // was not installed; create it and show it
          // and it has a button, just check it
          createGameButton(gg.get());
          ui->games->addButton(gg->button, QDialogButtonBox::AcceptRole);
        }

        gg->button->setChecked(true);
        gg->button->setFocus();
      } else {
        // this is not the button you're looking for
        if (gg->button) {
          gg->button->setChecked(false);
        }
      }
    }
  }

  QCommandLinkButton* createCustomButton()
  {
    auto* b = new QCommandLinkButton;

    b->setText(QObject::tr("Browse..."));
    b->setDescription(
      QObject::tr("The folder must contain a valid game installation"));

    QObject::connect(b, &QAbstractButton::clicked, [&] {
      selectCustom();
    });

    return b;
  }

  void createGameButton(Game* g)
  {
    g->button = new QCommandLinkButton;
    g->button->setCheckable(true);

    updateButton(g);

    QObject::connect(g->button, &QAbstractButton::clicked, [g, this] {
      select(g->game);
    });
  }

  void fillList()
  {
    const bool showAll = ui->showAllGames->isChecked();

    ui->games->clear();

    ui->games->addButton(createCustomButton(), QDialogButtonBox::AcceptRole);

    for (auto& g : m_games) {
      g->button = nullptr;

      if (!showAll && !g->installed) {
        // not installed
        continue;
      }

      createGameButton(g.get());
      ui->games->addButton(g->button, QDialogButtonBox::AcceptRole);
    }
  }

  Game* checkInstallation(const QString& path, Game* g)
  {
    if (g->game->looksValid(path)) {
      // okay
      return g;
    }

    // the selected game can't use that folder, find another one
    auto* otherGame = findAnotherGame(path);
    if (otherGame == g->game) {
      // shouldn't happen, but okay
      return g;
    }

    if (otherGame) {
      auto* confirmedGame = confirmOtherGame(path, g->game, otherGame);

      if (!confirmedGame) {
        // cancelled
        return nullptr;
      }

      // make it look like the user clicked that button instead
      g = findGame(confirmedGame);
      if (!g) {
        return nullptr;
      }
    } else {
      // nothing can manage this, but the user can override
      if (!confirmUnknown(path, g->game)) {
        // cancelled
        return nullptr;
      }
    }

    // remember this path
    g->dir = path;
    g->installed = true;

    updateButton(g);

    return g;
  }

  MOBase::IPluginGame* findAnotherGame(const QString& path)
  {
    for (auto* otherGame : m_pc.plugins<MOBase::IPluginGame>()) {
      if (otherGame->looksValid(path)) {
        return otherGame;
      }
    }

    return nullptr;
  }

  bool confirmUnknown(const QString& path, MOBase::IPluginGame* game)
  {
    const auto r = MOBase::TaskDialog(&m_dlg)
      .title(QObject::tr("Unrecognized game"))
      .main(QObject::tr("Unrecognized game"))
      .content(QObject::tr(
        "The folder %1 does not seem to contain an installation for "
        "<span style=\"white-space: nowrap; font-weight: bold;\">%2</span> or "
        "for any other game Mod Organizer can manage.")
          .arg(path)
          .arg(game->gameName()))
      .button({
        QObject::tr("Use this folder for %1").arg(game->gameName()),
        QObject::tr("I know what I'm doing"),
        QMessageBox::Ignore})
      .button({
        QObject::tr("Cancel"),
        QMessageBox::Cancel})
      .exec();

    return (r == QMessageBox::Ignore);
  }

  MOBase::IPluginGame* confirmOtherGame(
    const QString& path,
    MOBase::IPluginGame* selectedGame, MOBase::IPluginGame* guessedGame)
  {
    const auto r = MOBase::TaskDialog(&m_dlg)
      .title(QObject::tr("Incorrect game"))
      .main(QObject::tr("Incorrect game"))
      .content(QObject::tr(
        "The folder %1 seems to contain an installation for "
        "<span style=\"white-space: nowrap; font-weight: bold;\">%2</span>, "
        "not "
        "<span style=\"white-space: nowrap; font-weight: bold;\">%3</span>.")
          .arg(path)
          .arg(guessedGame->gameName())
          .arg(selectedGame->gameName()))
      .button({
        QObject::tr("Manage %1 instead").arg(guessedGame->gameName()),
        QMessageBox::Ok})
      .button({
        QObject::tr("Use this folder for %1").arg(selectedGame->gameName()),
        QObject::tr("I know what I'm doing"),
        QMessageBox::Ignore})
      .button({
        QObject::tr("Cancel"),
        QMessageBox::Cancel})
      .exec();

    switch (r)
    {
      case QMessageBox::Ok:
        return guessedGame;

      case QMessageBox::Ignore:
        return selectedGame;

      case QMessageBox::Cancel:
      default:
        return nullptr;
    }
  }
};


class EditionsPage : public Page
{
public:
  EditionsPage(CreateInstanceDialog& dlg)
    : Page(dlg), m_previousGame(nullptr)
  {
  }

  bool ready() const override
  {
    return !m_selection.isEmpty();
  }

  bool skip() const override
  {
    auto* g = m_dlg.selectedGame();
    if (!g) {
      // shouldn't happen
      return true;
    }

    const auto variants = g->gameVariants();
    return (variants.size() < 2);
  }

  void activated() override
  {
    auto* g = m_dlg.selectedGame();

    if (m_previousGame != g) {
      m_previousGame = g;
      m_selection = "";
      fillList();
    }
  }

  void select(const QString& variant)
  {
    for (auto* b : m_buttons) {
      if (b->text() == variant) {
        m_selection = variant;
        b->setChecked(true);
      } else {
        b->setChecked(false);
      }
    }

    updateNavigation();
  }

private:
  MOBase::IPluginGame* m_previousGame;
  std::vector<QCommandLinkButton*> m_buttons;
  QString m_selection;

  void fillList()
  {
    ui->editions->clear();
    m_buttons.clear();

    auto* g = m_dlg.selectedGame();
    if (!g) {
      // shouldn't happen
      return;
    }

    const auto variants = g->gameVariants();
    for (auto& v : variants) {
      auto* b = new QCommandLinkButton(v);
      b->setCheckable(true);

      QObject::connect(b, &QAbstractButton::clicked, [v, this] {
        select(v);
      });

      ui->editions->addButton(b, QDialogButtonBox::AcceptRole);
      m_buttons.push_back(b);
    }
  }
};


class NamePage : public Page
{
public:
  NamePage(CreateInstanceDialog& dlg) :
    Page(dlg), m_modified(false), m_okay(false),
    m_checker(ui->instanceNameExists, ui->instanceNameInvalid)
  {
    m_originalLabel = ui->instanceNameLabel->text();

    QObject::connect(
      ui->instanceName, &QLineEdit::textEdited, [&]{ onChanged(); });
  }

  bool ready() const override
  {
    return m_okay;
  }

  bool skip() const override
  {
    return (m_dlg.selectedType() == CreateInstanceDialog::Portable);
  }

  void activated() override
  {
    auto* g = m_dlg.selectedGame();
    if (!g) {
      // shouldn't happen, next should be disabled
      return;
    }

    ui->instanceNameLabel->setText(m_originalLabel.arg(g->gameName()));

    if (!m_modified || ui->instanceName->text().isEmpty()) {
      const auto n = InstanceManager::instance().makeUniqueName(g->gameName());
      ui->instanceName->setText(n);
      m_modified = false;
    }

    updateWarnings();
  }

  QString instanceName() const override
  {
    if (!m_okay) {
      return {};
    }

    const auto text = ui->instanceName->text().trimmed();
    return m_checker.sanitizeFileName(text);
  }

private:
  PathChecker m_checker;
  QString m_originalLabel;
  bool m_modified;
  bool m_okay;

  void onChanged()
  {
    m_modified = true;
    updateWarnings();
  }

  void updateWarnings()
  {
    const auto root = InstanceManager::instance().instancesPath();

    m_okay = m_checker.checkName(root, ui->instanceName->text());
    updateNavigation();
  }
};


class PathsPage : public Page
{
public:
  PathsPage(CreateInstanceDialog& dlg) :
    Page(dlg),
    m_checker(ui->locationExists, ui->locationInvalid),
    m_advancedChecker(ui->advancedDirExists, ui->advancedDirInvalid)
  {
    QObject::connect(ui->location, &QLineEdit::textEdited, [&]{ onChanged(); });
    QObject::connect(ui->base, &QLineEdit::textEdited, [&]{ onChanged(); });
    QObject::connect(ui->downloads, &QLineEdit::textEdited, [&]{ onChanged(); });
    QObject::connect(ui->mods, &QLineEdit::textEdited, [&]{ onChanged(); });
    QObject::connect(ui->profiles, &QLineEdit::textEdited, [&]{ onChanged(); });
    QObject::connect(ui->overwrite, &QLineEdit::textEdited, [&]{ onChanged(); });

    QObject::connect(
      ui->advancedPathOptions, &QCheckBox::clicked, [&]{ onAdvanced(); });

    ui->pathPages->setCurrentIndex(0);
  }

  bool skip() const override
  {
    return (m_dlg.selectedType() == CreateInstanceDialog::Portable);
  }

  bool ready() const override
  {
    return checkPaths();
  }

  void activated() override
  {
    const auto name = m_dlg.instanceName();

    setPaths(name, (m_lastInstanceName != name));
    checkPaths();
    updateNavigation();

    m_lastInstanceName = name;
  }

private:
  PathChecker m_checker, m_advancedChecker;
  QString m_lastInstanceName;

  void onChanged()
  {
    checkPaths();
    updateNavigation();
  }

  bool checkPaths() const
  {
    if (ui->advancedPathOptions->isChecked()) {
      return
        checkAdvancedPath(ui->base->text()) &&
        checkVarPath(ui->downloads->text());
    } else {
      return m_checker.checkPath(ui->location->text());
    }
  }

  bool checkAdvancedPath(const QString& path) const
  {
    return m_advancedChecker.checkPath(path);
  }

  bool checkVarPath(QString path) const
  {
    path.replace("%BASE_DIR%", ui->base->text());
    return checkAdvancedPath(path);
  }

  void onAdvanced()
  {
    if (ui->advancedPathOptions->isChecked()) {
      ui->base->setText(ui->location->text());
      ui->pathPages->setCurrentIndex(1);
    } else {
      ui->location->setText(ui->base->text());
      ui->pathPages->setCurrentIndex(0);
    }

    checkPaths();
  }

  void setPaths(const QString& name, bool force)
  {
    const auto root = InstanceManager::instance().instancesPath();
    const auto path = QDir::toNativeSeparators(root + "/" + name);

    setIfEmpty(ui->location, path, force);

    setIfEmpty(ui->base, path, force);
    setIfEmpty(ui->downloads, makeDefaultPath(AppConfig::downloadPath()), force);
    setIfEmpty(ui->mods, makeDefaultPath(AppConfig::modsPath()), force);
    setIfEmpty(ui->profiles, makeDefaultPath(AppConfig::profilesPath()), force);
    setIfEmpty(ui->overwrite, makeDefaultPath(AppConfig::overwritePath()), force);
  }

  void setIfEmpty(QLineEdit* e, const QString& path, bool force)
  {
    if (e->text().isEmpty() || force) {
      e->setText(path);
    }
  }

  QString makeDefaultPath(const std::wstring& dir)
  {
    return "%BASE_DIR%\\" + QString::fromStdWString(dir);
  }
};

} // namespace


CreateInstanceDialog::CreateInstanceDialog(
  const PluginContainer& pc, QWidget *parent)
    : QDialog(parent), ui(new Ui::CreateInstanceDialog), m_pc(pc)
{
  using namespace cid;

  ui->setupUi(this);
  m_originalNext = ui->next->text();

  m_pages.push_back(std::make_unique<InfoPage>(*this));
  m_pages.push_back(std::make_unique<TypePage>(*this));
  m_pages.push_back(std::make_unique<GamePage>(*this));
  m_pages.push_back(std::make_unique<EditionsPage>(*this));
  m_pages.push_back(std::make_unique<NamePage>(*this));
  m_pages.push_back(std::make_unique<PathsPage>(*this));
  m_pages.push_back(std::make_unique<InfoPage>(*this));

  ui->pages->setCurrentIndex(0);

  updateNavigation();

  connect(ui->next, &QPushButton::clicked, [&]{ next(); });
  connect(ui->back, &QPushButton::clicked, [&]{ back(); });
}

CreateInstanceDialog::~CreateInstanceDialog() = default;

Ui::CreateInstanceDialog* CreateInstanceDialog::getUI()
{
  return ui.get();
}

const PluginContainer& CreateInstanceDialog::pluginContainer()
{
  return m_pc;
}

bool CreateInstanceDialog::isOnLastPage() const
{
  for (int i=ui->pages->currentIndex() + 1; i < ui->pages->count(); ++i) {
    if (!m_pages[i]->skip()) {
      return false;
    }
  }

  return true;
}

void CreateInstanceDialog::next()
{
  const auto i = ui->pages->currentIndex();
  const auto last = isOnLastPage();

  if (last) {
    finish();
  } else {
    changePage(+1);
  }
}

void CreateInstanceDialog::back()
{
  changePage(-1);
}

void CreateInstanceDialog::changePage(int d)
{
  std::size_t i = static_cast<std::size_t>(ui->pages->currentIndex());

  if (d > 0) {
    for (;;) {
      ++i;

      if (i >= m_pages.size()) {
        break;
      }

      if (!m_pages[i]->skip()) {
        break;
      }
    }
  } else {
    for (;;) {
      if (i == 0) {
        break;
      }

      --i;

      if (!m_pages[i]->skip()) {
        break;
      }
    }
  }

  if (i < m_pages.size()) {
    selectPage(i);
  }
}

void CreateInstanceDialog::finish()
{
}

void CreateInstanceDialog::selectPage(std::size_t i)
{
  if (i >= m_pages.size()) {
    return;
  }

  ui->pages->setCurrentIndex(static_cast<int>(i));
  m_pages[i]->activated();

  updateNavigation();
}

void CreateInstanceDialog::updateNavigation()
{
  const auto i = ui->pages->currentIndex();
  const auto last = isOnLastPage();

  ui->next->setEnabled(m_pages[i]->ready());
  ui->back->setEnabled(i > 0);

  if (last) {
    ui->next->setText(tr("Finish"));
  } else {
    ui->next->setText(m_originalNext);
  }
}

CreateInstanceDialog::Types CreateInstanceDialog::selectedType() const
{
  for (auto&& p : m_pages) {
    const auto t = p->selectedType();
    if (t != NoType) {
      return t;
    }
  }

  return NoType;
}

MOBase::IPluginGame* CreateInstanceDialog::selectedGame() const
{
  for (auto&& p : m_pages) {
    if (auto* g=p->selectedGame()) {
      return g;
    }
  }

  return nullptr;
}

QString CreateInstanceDialog::instanceName() const
{
  for (auto&& p : m_pages) {
    const auto s = p->instanceName();
    if (!s.isEmpty()) {
      return s;
    }
  }

  return {};
}