/*
 * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#include "core/html/forms/StepRange.h"

#include "core/HTMLNames.h"
#include "core/html/parser/HTMLParserIdioms.h"
#include "wtf/MathExtras.h"
#include "wtf/text/WTFString.h"
#include <float.h>

namespace blink {

using namespace HTMLNames;

StepRange::StepRange()
    : m_maximum(100),
      m_minimum(0),
      m_step(1),
      m_stepBase(0),
      m_hasStep(false),
      m_hasRangeLimitations(false) {}

StepRange::StepRange(const StepRange& stepRange)
    : m_maximum(stepRange.m_maximum),
      m_minimum(stepRange.m_minimum),
      m_step(stepRange.m_step),
      m_stepBase(stepRange.m_stepBase),
      m_stepDescription(stepRange.m_stepDescription),
      m_hasStep(stepRange.m_hasStep),
      m_hasRangeLimitations(stepRange.m_hasRangeLimitations) {}

StepRange::StepRange(const Decimal& stepBase,
                     const Decimal& minimum,
                     const Decimal& maximum,
                     bool hasRangeLimitations,
                     const Decimal& step,
                     const StepDescription& stepDescription)
    : m_maximum(maximum),
      m_minimum(minimum),
      m_step(step.isFinite() ? step : 1),
      m_stepBase(stepBase.isFinite() ? stepBase : 1),
      m_stepDescription(stepDescription),
      m_hasStep(step.isFinite()),
      m_hasRangeLimitations(hasRangeLimitations) {
  DCHECK(m_maximum.isFinite());
  DCHECK(m_minimum.isFinite());
  DCHECK(m_step.isFinite());
  DCHECK(m_stepBase.isFinite());
}

Decimal StepRange::acceptableError() const {
  // FIXME: We should use DBL_MANT_DIG instead of FLT_MANT_DIG regarding to
  // HTML5 specification.
  DEFINE_STATIC_LOCAL(const Decimal, twoPowerOfFloatMantissaBits,
                      (Decimal::Positive, 0, UINT64_C(1) << FLT_MANT_DIG));
  return m_stepDescription.stepValueShouldBe == StepValueShouldBeReal
             ? m_step / twoPowerOfFloatMantissaBits
             : Decimal(0);
}

Decimal StepRange::alignValueForStep(const Decimal& currentValue,
                                     const Decimal& newValue) const {
  DEFINE_STATIC_LOCAL(const Decimal, tenPowerOf21, (Decimal::Positive, 21, 1));
  if (newValue >= tenPowerOf21)
    return newValue;

  return stepMismatch(currentValue) ? newValue
                                    : roundByStep(newValue, m_stepBase);
}

Decimal StepRange::clampValue(const Decimal& value) const {
  const Decimal inRangeValue = std::max(m_minimum, std::min(value, m_maximum));
  if (!m_hasStep)
    return inRangeValue;
  // Rounds inRangeValue to stepBase + N * step.
  const Decimal roundedValue = roundByStep(inRangeValue, m_stepBase);
  const Decimal clampedValue =
      roundedValue > m_maximum
          ? roundedValue - m_step
          : (roundedValue < m_minimum ? roundedValue + m_step : roundedValue);
  // clampedValue can be outside of [m_minimum, m_maximum] if m_step is huge.
  if (clampedValue < m_minimum || clampedValue > m_maximum)
    return inRangeValue;
  return clampedValue;
}

Decimal StepRange::parseStep(AnyStepHandling anyStepHandling,
                             const StepDescription& stepDescription,
                             const String& stepString) {
  if (stepString.isEmpty())
    return stepDescription.defaultValue();

  if (equalIgnoringCase(stepString, "any")) {
    switch (anyStepHandling) {
      case RejectAny:
        return Decimal::nan();
      case AnyIsDefaultStep:
        return stepDescription.defaultValue();
      default:
        NOTREACHED();
    }
  }

  Decimal step = parseToDecimalForNumberType(stepString);
  if (!step.isFinite() || step <= 0)
    return stepDescription.defaultValue();

  switch (stepDescription.stepValueShouldBe) {
    case StepValueShouldBeReal:
      step *= stepDescription.stepScaleFactor;
      break;
    case ParsedStepValueShouldBeInteger:
      // For date, month, and week, the parsed value should be an integer for
      // some types.
      step = std::max(step.round(), Decimal(1));
      step *= stepDescription.stepScaleFactor;
      break;
    case ScaledStepValueShouldBeInteger:
      // For datetime, datetime-local, time, the result should be an integer.
      step *= stepDescription.stepScaleFactor;
      step = std::max(step.round(), Decimal(1));
      break;
    default:
      NOTREACHED();
  }

  DCHECK_GT(step, 0);
  return step;
}

Decimal StepRange::roundByStep(const Decimal& value,
                               const Decimal& base) const {
  return base + ((value - base) / m_step).round() * m_step;
}

bool StepRange::stepMismatch(const Decimal& valueForCheck) const {
  if (!m_hasStep)
    return false;
  if (!valueForCheck.isFinite())
    return false;
  const Decimal value = (valueForCheck - m_stepBase).abs();
  if (!value.isFinite())
    return false;
  // Decimal's fractional part size is DBL_MAN_DIG-bit. If the current value
  // is greater than step*2^DBL_MANT_DIG, the following computation for
  // remainder makes no sense.
  DEFINE_STATIC_LOCAL(const Decimal, twoPowerOfDoubleMantissaBits,
                      (Decimal::Positive, 0, UINT64_C(1) << DBL_MANT_DIG));
  if (value / twoPowerOfDoubleMantissaBits > m_step)
    return false;
  // The computation follows HTML5 4.10.7.2.10 `The step attribute' :
  // ... that number subtracted from the step base is not an integral multiple
  // of the allowed value step, the element is suffering from a step mismatch.
  const Decimal remainder = (value - m_step * (value / m_step).round()).abs();
  // Accepts errors in lower fractional part which IEEE 754 single-precision
  // can't represent.
  const Decimal computedAcceptableError = acceptableError();
  return computedAcceptableError < remainder &&
         remainder < (m_step - computedAcceptableError);
}

Decimal StepRange::stepSnappedMaximum() const {
  Decimal base = stepBase();
  Decimal step = this->step();
  if (base - step == base || !(base / step).isFinite())
    return Decimal::nan();
  Decimal alignedMaximum = base + ((maximum() - base) / step).floor() * step;
  if (alignedMaximum > maximum())
    alignedMaximum -= step;
  DCHECK_LE(alignedMaximum, maximum());
  if (alignedMaximum < minimum())
    return Decimal::nan();
  return alignedMaximum;
}

}  // namespace blink