#include "SettingsController.h"

#include <QKeyCombination>
#include <QKeySequence>

SettingsController::SettingsController(QObject* parent) : QObject(parent) {}

void SettingsController::setDraftFamily(const QString& family)
{
  if (m_draftFamily == family) {
    return;
  }
  m_draftFamily = family;
  emit draftFamilyChanged();
}

void SettingsController::setDraftSize(qreal size)
{
  if (m_draftSize == size) {
    return;
  }
  m_draftSize = size;
  emit draftSizeChanged();
}

void SettingsController::setDraftWeight(int weight)
{
  if (m_draftWeight == weight) {
    return;
  }
  m_draftWeight = weight;
  emit draftWeightChanged();
}

void SettingsController::setRestartDraft(const QVariantList& draft)
{
  if (m_restartDraft == draft) {
    return;
  }
  m_restartDraft = draft;
  emit restartDraftChanged();
}

XenoSettings* SettingsController::settings() const { return effectiveSettings(); }

void SettingsController::setSettings(XenoSettings* settings)
{
  if (m_settings == settings) {
    return;
  }
  m_settings = settings;
  emit settingsChanged();
}

FontCatalog* SettingsController::catalog() const
{
  if (m_catalog) {
    return m_catalog;
  }
  return AppModel::instance()->fontCatalog();
}

void SettingsController::setCatalog(FontCatalog* catalog)
{
  if (m_catalog == catalog) {
    return;
  }
  m_catalog = catalog;
  emit catalogChanged();
}

XenoSettings* SettingsController::effectiveSettings() const
{
  if (m_settings) {
    return m_settings;
    }
  return AppModel::instance()->settings();
}

void SettingsController::seed(const QString& family, qreal size, int weight)
{
  setDraftFamily(family);
  setDraftSize(size > 0 ? size : 9);
  setDraftWeight(weight > 0 ? weight : 400);
}

void SettingsController::seedFromSettings()
{
  XenoSettings* s = effectiveSettings();
  if (!s) {
    return;
  }
  seed(s->fontFamily(), s->fontSize(), s->fontWeight());
}

void SettingsController::commitFont()
{
  XenoSettings* s = effectiveSettings();
  if (!s) {
    return;
  }
  s->setFontFamily(m_draftFamily);
  s->setFontSize(m_draftSize);
  s->setFontWeight(m_draftWeight);
}

void SettingsController::commitRestart()
{
  XenoSettings* s = effectiveSettings();
  if (!s) {
    return;
  }
  QVariantList matches;
  matches.reserve(m_restartDraft.size());
  for (const QVariant& entry : m_restartDraft) {
    const QVariantMap e = entry.toMap();
    matches.append(QVariantMap {
        { "kind", e.value("kind").toString() == "path" ? QStringLiteral("path")
                                                       : QStringLiteral("name") },
        { "value", e.value("value").toString() },
    });
  }
  s->setProcessRestartMatches(matches);
}

void SettingsController::addRestartEntry(const QString& kind, const QString& value)
{
  if (value.isEmpty()) {
    return;
  }
  m_restartDraft.append(
      QVariantMap { { "kind", kind == "path" ? QStringLiteral("path") : QStringLiteral("name") },
                    { "value", value } });
  emit restartDraftChanged();
}

void SettingsController::removeRestartEntry(int index)
{
  if (index < 0 || index >= m_restartDraft.size()) {
    return;
  }
  m_restartDraft.removeAt(index);
  emit restartDraftChanged();
}

QString SettingsController::sequenceFromKey(int key, int modifiers)
{
  if (key == Qt::Key_unknown || key == 0) {
    return {};
  }
  // Modifier-only presses cannot start a sequence.
  switch (key) {
  case Qt::Key_Shift:
  case Qt::Key_Control:
  case Qt::Key_Alt:
  case Qt::Key_Meta:
  case Qt::Key_AltGr:
  case Qt::Key_CapsLock:
  case Qt::Key_NumLock:
  case Qt::Key_ScrollLock:
    return {};
  default:
    break;
  }
  return QKeySequence(QKeyCombination::fromCombined(modifiers | key))
      .toString(QKeySequence::PortableText);
}