/*
 * (C) 1999-2003 Lars Knoll (knoll@kde.org)
 * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
 *
 * 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.
 */

#ifndef CSSPrimitiveValue_h
#define CSSPrimitiveValue_h

#include "core/CSSPropertyNames.h"
#include "core/CSSValueKeywords.h"
#include "core/CoreExport.h"
#include "core/css/CSSValue.h"
#include "wtf/BitVector.h"
#include "wtf/Forward.h"
#include "wtf/MathExtras.h"
#include "wtf/text/StringHash.h"
#include "wtf/text/StringView.h"

namespace blink {

class CSSCalcValue;
class CSSToLengthConversionData;
class Length;

// Dimension calculations are imprecise, often resulting in values of e.g.
// 44.99998. We need to go ahead and round if we're really close to the next
// integer value.
template <typename T>
inline T roundForImpreciseConversion(double value) {
  value += (value < 0) ? -0.01 : +0.01;
  return ((value > std::numeric_limits<T>::max()) ||
          (value < std::numeric_limits<T>::min()))
             ? 0
             : static_cast<T>(value);
}

template <>
inline float roundForImpreciseConversion(double value) {
  double ceiledValue = ceil(value);
  double proximityToNextInt = ceiledValue - value;
  if (proximityToNextInt <= 0.01 && value > 0)
    return static_cast<float>(ceiledValue);
  if (proximityToNextInt >= 0.99 && value < 0)
    return static_cast<float>(floor(value));
  return static_cast<float>(value);
}

// CSSPrimitiveValue stores numeric data types (e.g. 1, 10px, 4%) and calc()
// values (e.g. calc(3px + 2em)).
class CORE_EXPORT CSSPrimitiveValue : public CSSValue {
 public:
  // These units are iterated through, so be careful when adding or changing the
  // order.
  enum class UnitType {
    Unknown,
    Number,
    Percentage,
    // Length units
    Ems,
    Exs,
    Pixels,
    Centimeters,
    Millimeters,
    Inches,
    Points,
    Picas,
    ViewportWidth,
    ViewportHeight,
    ViewportMin,
    ViewportMax,
    Rems,
    Chs,
    UserUnits,  // The SVG term for unitless lengths
    // Angle units
    Degrees,
    Radians,
    Gradians,
    Turns,
    // Time units
    Milliseconds,
    Seconds,
    Hertz,
    Kilohertz,
    // Resolution
    DotsPerPixel,
    DotsPerInch,
    DotsPerCentimeter,
    // Other units
    Fraction,
    Integer,
    Calc,
    CalcPercentageWithNumber,
    CalcPercentageWithLength,
    CalcLengthWithNumber,
    CalcPercentageWithLengthAndNumber,

    // This value is used to handle quirky margins in reflow roots (body, td,
    // and th) like WinIE. The basic idea is that a stylesheet can use the value
    // __qem (for quirky em) instead of em. When the quirky value is used, if
    // you're in quirks mode, the margin will collapse away inside a table cell.
    // This quirk is specified in the HTML spec but our impl is different.
    // TODO: Remove this. crbug.com/443952
    QuirkyEms,
  };

  enum LengthUnitType {
    UnitTypePixels = 0,
    UnitTypePercentage,
    UnitTypeFontSize,
    UnitTypeFontXSize,
    UnitTypeRootFontSize,
    UnitTypeZeroCharacterWidth,
    UnitTypeViewportWidth,
    UnitTypeViewportHeight,
    UnitTypeViewportMin,
    UnitTypeViewportMax,

    // This value must come after the last length unit type to enable iteration
    // over the length unit types.
    LengthUnitTypeCount,
  };

  struct CSSLengthArray {
    CSSLengthArray() : values(LengthUnitTypeCount) {
      typeFlags.resize(LengthUnitTypeCount);
    }

    Vector<double, CSSPrimitiveValue::LengthUnitTypeCount> values;
    BitVector typeFlags;
  };

  void accumulateLengthArray(CSSLengthArray&, double multiplier = 1) const;

  enum UnitCategory {
    UNumber,
    UPercent,
    ULength,
    UAngle,
    UTime,
    UFrequency,
    UResolution,
    UOther
  };
  static UnitCategory unitTypeToUnitCategory(UnitType);
  static float clampToCSSLengthRange(double);

  static bool isAngle(UnitType unit) {
    return unit == UnitType::Degrees || unit == UnitType::Radians ||
           unit == UnitType::Gradians || unit == UnitType::Turns;
  }
  bool isAngle() const { return isAngle(type()); }
  bool isFontRelativeLength() const {
    return type() == UnitType::QuirkyEms || type() == UnitType::Ems ||
           type() == UnitType::Exs || type() == UnitType::Rems ||
           type() == UnitType::Chs;
  }
  bool isQuirkyEms() const { return type() == UnitType::QuirkyEms; }
  bool isViewportPercentageLength() const {
    return isViewportPercentageLength(type());
  }
  static bool isViewportPercentageLength(UnitType type) {
    return type >= UnitType::ViewportWidth && type <= UnitType::ViewportMax;
  }
  static bool isLength(UnitType type) {
    return (type >= UnitType::Ems && type <= UnitType::UserUnits) ||
           type == UnitType::QuirkyEms;
  }
  static inline bool isRelativeUnit(UnitType type) {
    return type == UnitType::Percentage || type == UnitType::Ems ||
           type == UnitType::Exs || type == UnitType::Rems ||
           type == UnitType::Chs || isViewportPercentageLength(type);
  }
  bool isLength() const { return isLength(typeWithCalcResolved()); }
  bool isNumber() const {
    return typeWithCalcResolved() == UnitType::Number ||
           typeWithCalcResolved() == UnitType::Integer;
  }
  bool isPercentage() const {
    return typeWithCalcResolved() == UnitType::Percentage;
  }
  bool isPx() const { return typeWithCalcResolved() == UnitType::Pixels; }
  bool isTime() const {
    return type() == UnitType::Seconds || type() == UnitType::Milliseconds;
  }
  bool isCalculated() const { return type() == UnitType::Calc; }
  bool isCalculatedPercentageWithNumber() const {
    return typeWithCalcResolved() == UnitType::CalcPercentageWithNumber;
  }
  bool isCalculatedPercentageWithLength() const {
    return typeWithCalcResolved() == UnitType::CalcPercentageWithLength;
  }
  static bool isResolution(UnitType type) {
    return type >= UnitType::DotsPerPixel &&
           type <= UnitType::DotsPerCentimeter;
  }
  bool isFlex() const { return typeWithCalcResolved() == UnitType::Fraction; }

  static CSSPrimitiveValue* create(double value, UnitType);
  static CSSPrimitiveValue* create(const Length& value, float zoom) {
    return new CSSPrimitiveValue(value, zoom);
  }

  // TODO(sashab): Remove this.
  template <typename T>
  static CSSPrimitiveValue* create(T value) {
    return new CSSPrimitiveValue(value);
  }

  ~CSSPrimitiveValue();

  UnitType typeWithCalcResolved() const;

  double computeDegrees() const;
  double computeSeconds() const;

  // Computes a length in pixels, resolving relative lengths
  template <typename T>
  T computeLength(const CSSToLengthConversionData&) const;

  // Converts to a Length (Fixed, Percent or Calculated)
  Length convertToLength(const CSSToLengthConversionData&) const;

  double getDoubleValue() const;
  float getFloatValue() const { return getValue<float>(); }
  int getIntValue() const { return getValue<int>(); }
  template <typename T>
  inline T getValue() const {
    return clampTo<T>(getDoubleValue());
  }

  CSSCalcValue* cssCalcValue() const {
    ASSERT(isCalculated());
    return m_value.calc;
  }

  template <typename T>
  inline T convertTo() const;  // Defined in CSSPrimitiveValueMappings.h

  static const char* unitTypeToString(UnitType);
  static UnitType stringToUnitType(StringView string) {
    if (string.is8Bit())
      return stringToUnitType(string.characters8(), string.length());
    return stringToUnitType(string.characters16(), string.length());
  }

  String customCSSText() const;

  bool equals(const CSSPrimitiveValue&) const;

  DECLARE_TRACE_AFTER_DISPATCH();

  static UnitType canonicalUnitTypeForCategory(UnitCategory);
  static double conversionToCanonicalUnitsScaleFactor(UnitType);

  // Returns true and populates lengthUnitType, if unitType is a length unit.
  // Otherwise, returns false.
  static bool unitTypeToLengthUnitType(UnitType, LengthUnitType&);
  static UnitType lengthUnitTypeToUnitType(LengthUnitType);

 private:
  CSSPrimitiveValue(const Length&, float zoom);
  CSSPrimitiveValue(double, UnitType);

  template <typename T>
  CSSPrimitiveValue(T);  // Defined in CSSPrimitiveValueMappings.h

  template <typename T>
  CSSPrimitiveValue(T* val) : CSSValue(PrimitiveClass) {
    init(val);
  }

  static void create(int);       // compile-time guard
  static void create(unsigned);  // compile-time guard
  template <typename T>
  operator T*();  // compile-time guard

  // Code generated by CSSPrimitiveValueUnitTrie.cpp.tmpl
  static UnitType stringToUnitType(const LChar*, unsigned length);
  static UnitType stringToUnitType(const UChar*, unsigned length);

  void init(UnitType);
  void init(const Length&);
  void init(CSSCalcValue*);

  double computeLengthDouble(const CSSToLengthConversionData&) const;

  inline UnitType type() const {
    return static_cast<UnitType>(m_primitiveUnitType);
  }

  union {
    double num;
    // FIXME: oilpan: Should be a member, but no support for members in unions.
    // Just trace the raw ptr for now.
    CSSCalcValue* calc;
  } m_value;
};

using CSSLengthArray = CSSPrimitiveValue::CSSLengthArray;

DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());

}  // namespace blink

#endif  // CSSPrimitiveValue_h