#include "lts_spinbox.h"

#include <cmath>

namespace LtsWidgets
{

LtsSpinBox::LtsSpinBox(QWidget *parent)
  : QSpinBox(parent)
{
}

QValidator::State LtsSpinBox::validate(QString &input, int &pos) const
{
  QIntValidator validator;
  for (auto range : m_validRanges)
  {
    validator.setBottom(range.first);
    validator.setTop(range.second);
    QValidator::State state = validator.validate(input, pos);
    if (state == QValidator::Invalid ||
        state == QValidator::Intermediate)
      return state;
  }

  
  int value = input.toInt();
  value -= minimum();
  return (value % singleStep() == 0) ? QValidator::Acceptable : QValidator::Intermediate;
}

void LtsSpinBox::fixup(QString &str) const
{
  QSpinBox::fixup(str);

  if (singleStep() == 1)
    return;

  bool bOk;
  int value = str.toInt(&bOk);
  if (!bOk)
    return;

  int remainder = (value - minimum()) % singleStep();

  if (2 * remainder > singleStep())
    value += singleStep();

  value -= remainder;

  if (value > maximum())
    value -= singleStep();

  str = QString::number(value);
}

bool LtsSpinBox::setExclusionRanges(const QVector<QPair<int,int> > &exclusionRanges, bool preserveCurrentValues)
{
  bool retVal = true;
  
  auto newExclusions = exclusionRanges;
  
  if (preserveCurrentValues)
    newExclusions += m_exclusions;
  
  for (auto &elem : newExclusions)
  {
    if (elem.first > elem.second)
    {
      int tmp = elem.first;
      elem.first= elem.second;
      elem.second = tmp;
    }
  }
  
  std::sort(newExclusions.begin(), newExclusions.end(), [](const QPair<int,int> &a, const QPair<int,int> &b) { return a.first < b.first; });
  for (int i=0; i<newExclusions.size()-1; ++i)
  {
    
    if (newExclusions[i].second >= newExclusions[i+1].first)
    {
      retVal = false;
      break;
    }
  }
  
  if (!retVal || newExclusions[0].first <= minimum() || newExclusions[newExclusions.size()-1].second >= maximum())
  {
    
    if (!preserveCurrentValues)
      m_exclusions.clear();
    return false;
  }
  
  m_exclusions = exclusionRanges;

  
  m_validRanges.clear();
  if (m_exclusions[0].first - 1 > minimum())
    m_validRanges.append({minimum(), m_exclusions[0].first - 1});
  for (int i=0; i<m_exclusions.size()-1; ++i)
  {
    
    if (m_exclusions[i].second + 1 < m_exclusions[i+1].first - 1)
      m_validRanges.append({m_exclusions[i].second + 1, m_exclusions[i+1].first - 1});
  }
  if (m_exclusions[m_exclusions.size()-1].second + 1 < maximum())
    m_validRanges.append({m_exclusions[0].first - 1, maximum()});

  return true;
}

bool LtsSpinBox::addExclusionRange(int min, int max)
{
  return setExclusionRanges({{min, max}}, true);
}

void LtsSpinBox::clearExclusionRanges()
{
  m_exclusions.clear();
}


LtsDoubleSpinBox::LtsDoubleSpinBox(QWidget *parent)
  : QDoubleSpinBox(parent)
{
}

QValidator::State LtsDoubleSpinBox::validate(QString &input, int &pos) const
{
  QDoubleValidator validator;
  validator.setBottom(minimum());
  validator.setTop(maximum());
  QValidator::State state = validator.validate(input, pos);
  if (state == QValidator::Invalid ||
      state == QValidator::Intermediate)
    return state;

  
  double value = input.toDouble();
  value -= minimum();
  return qFuzzyCompare(std::fmod(value, singleStep()), 0.0) ? QValidator::Acceptable : QValidator::Intermediate;
}

void LtsDoubleSpinBox::fixup(QString &str) const
{
  QDoubleSpinBox::fixup(str);

  if (qFuzzyCompare(singleStep(), pow(10, decimals())))
    return;

  bool bOk;
  double value = str.toDouble(&bOk);
  if (!bOk)
    return;

  double remainder = std::fmod(value - minimum(), singleStep());

  if (2 * remainder > singleStep())
    value += singleStep();

  value -= remainder;

  if (value > maximum())
    value -= singleStep();

  str = QString::number(value, 'f', decimals());
}

}