#include "SettingsController.h"

#include <QKeyCombination>
#include <QKeySequence>

#include <algorithm>

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::setDraftEditorSize(qreal size)
{
  const qreal clamped = std::clamp(size, 1.0, 128.0);
  if (m_draftEditorSize == clamped) {
    return;
  }
  m_draftEditorSize = clamped;
  emit draftEditorSizeChanged();
}

void SettingsController::setDraftEditorLineHeight(qreal factor)
{
  const qreal clamped = std::clamp(factor, 1.0, 3.0);
  if (m_draftEditorLineHeight == clamped) {
    return;
  }
  m_draftEditorLineHeight = clamped;
  emit draftEditorLineHeightChanged();
}

void SettingsController::setDraftEditorWrap(bool wrap)
{
  if (m_draftEditorWrap == wrap) {
    return;
  }
  m_draftEditorWrap = wrap;
  emit draftEditorWrapChanged();
}

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());
  // The editor's size falls back to the terminal's, then to 9.
  const qreal terminalSize = s->fontSize() > 0.0 ? s->fontSize() : 9.0;
  setDraftEditorSize(s->editorFontSize() > 0.0 ? s->editorFontSize()
                                               : terminalSize);
  setDraftEditorLineHeight(s->editorLineHeight());
  setDraftEditorWrap(s->editorWrap());
}

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

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);
}