// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef COBALT_LAYOUT_LAYOUT_UNIT_H_
#define COBALT_LAYOUT_LAYOUT_UNIT_H_

#include <cmath>

#include <algorithm>
#include <iostream>
#include <utility>

#include "base/basictypes.h"
#include "base/logging.h"

namespace cobalt {
namespace layout {

// This is used to represent distances and positions during layout.
class LayoutUnit {
 public:
  // The ratio of the LayoutUnit fixed point value to integers.
  static const int kFixedPointRatio = 64;

  LayoutUnit() : value_(0) {
#ifdef _DEBUG
    is_nan_ = false;
#endif
  }
  ~LayoutUnit() {}

  // Constructors.
  explicit LayoutUnit(int value) : value_(value * kFixedPointRatio) {
#ifdef _DEBUG
    int64_t value64 = value * kFixedPointRatio;
    is_nan_ = value_ != value64;
#endif
  }
  explicit LayoutUnit(float value)
      : value_(static_cast<int32_t>(
            floorf(value * static_cast<float>(kFixedPointRatio)))) {
#ifdef _DEBUG
    int64_t value64 = static_cast<int64_t>(
        floorf(value * static_cast<float>(kFixedPointRatio)));
    is_nan_ = value_ != value64;
#endif
  }

  float toFloat() const {
    return static_cast<float>(value_) / kFixedPointRatio;
  }

  void swap(LayoutUnit& value) {
    std::swap(value_, value.value_);
#ifdef _DEBUG
    std::swap(is_nan_, value.is_nan_);
#endif
  }

  // Copy assignment operator.
  LayoutUnit& operator=(LayoutUnit value) {
    value_ = value.value_;
#ifdef _DEBUG
    is_nan_ = is_nan_ || value.is_nan_;
#endif
    return *this;
  }

  bool operator<(LayoutUnit other) const { return value_ < other.value_; }
  bool operator<=(LayoutUnit other) const { return value_ <= other.value_; }
  bool operator>(LayoutUnit other) const { return value_ > other.value_; }
  bool operator>=(LayoutUnit other) const { return value_ >= other.value_; }
  bool operator==(LayoutUnit other) const { return value_ == other.value_; }
  bool operator!=(LayoutUnit other) const { return value_ != other.value_; }

#ifdef _DEBUG
  bool LessThanOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this < other;
  }
  bool LessEqualOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this <= other;
  }
  bool GreaterThanOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this > other;
  }
  bool GreaterEqualOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this >= other;
  }
  bool EqualOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this == other;
  }
  bool NotEqualOrNaN(LayoutUnit other) const {
    return is_nan_ || other.is_nan_ || *this != other;
  }
  bool IsNaN() const { return is_nan_; }
#else
  bool LessThanOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this < other;
  }
  bool LessEqualOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this <= other;
  }
  bool GreaterThanOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this > other;
  }
  bool GreaterEqualOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this >= other;
  }
  bool EqualOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this == other;
  }
  bool NotEqualOrNaN(LayoutUnit other) const {
    NOTREACHED();
    return *this != other;
  }
  bool IsNaN() const {
    NOTREACHED();
    return false;
  }
#endif

  LayoutUnit operator+() const { return LayoutUnit(*this); }
  LayoutUnit operator-() const {
    LayoutUnit res;
    res.value_ = -value_;
    return res;
  }

  LayoutUnit& operator+=(LayoutUnit other) {
#ifdef _DEBUG
    int64_t value64 = value_;
#endif
    value_ += other.value_;
#ifdef _DEBUG
    is_nan_ = is_nan_ || other.is_nan_ ||
              (value_ != (value64 + static_cast<int64_t>(other.value_)));
#endif
    return *this;
  }
  LayoutUnit operator+(LayoutUnit other) const {
    LayoutUnit res(*this);
    return res += other;
  }
  LayoutUnit& operator-=(LayoutUnit other) {
#ifdef _DEBUG
    int64_t value64 = value_;
#endif
    value_ -= other.value_;
#ifdef _DEBUG
    is_nan_ = is_nan_ || other.is_nan_ ||
              (value_ != (value64 - static_cast<int64_t>(other.value_)));
#endif
    return *this;
  }
  LayoutUnit operator-(LayoutUnit other) const {
    LayoutUnit res(*this);
    return res -= other;
  }

  // Scaling math operators.

  // NOLINTNEXTLINE(runtime/references)
  friend LayoutUnit& operator*=(LayoutUnit& a, int b);
  // NOLINTNEXTLINE(runtime/references)
  friend LayoutUnit& operator/=(LayoutUnit& a, int b);
  // NOLINTNEXTLINE(runtime/references)
  friend LayoutUnit& operator*=(LayoutUnit& a, float b);
  // NOLINTNEXTLINE(runtime/references)
  friend LayoutUnit& operator/=(LayoutUnit& a, float b);

 private:
  int32_t value_;
#ifdef _DEBUG
  // When value_ overflows or underflows during construction or during an
  // operation, it's value is undefined. This flags is used to track when that
  // happens. The value propagates to the result of operations where any
  // operand has this flag set, to indicate that there is undefined behavior.
  bool is_nan_;
#endif
};

// Integer scaling math operators.

// NOLINTNEXTLINE(runtime/references)
inline LayoutUnit& operator*=(LayoutUnit& a, int b) {
#ifdef _DEBUG
  int64_t value64 = a.value_;
#endif
  a.value_ *= b;
#ifdef _DEBUG
  a.is_nan_ = a.is_nan_ || (a.value_ != (value64 * b));
#endif
  return a;
}

inline LayoutUnit operator*(LayoutUnit a, int b) { return a *= b; }

inline LayoutUnit operator*(int a, LayoutUnit b) { return b *= a; }

// NOLINTNEXTLINE(runtime/references)
inline LayoutUnit& operator/=(LayoutUnit& a, int b) {
#ifdef _DEBUG
  int64_t value64 = a.value_;
#endif
  a.value_ /= b;
#ifdef _DEBUG
  a.is_nan_ = a.is_nan_ || (a.value_ != (value64 / b));
#endif
  return a;
}

inline LayoutUnit operator/(LayoutUnit a, int b) { return a /= b; }

// Floating point scaling math operators.

// NOLINTNEXTLINE(runtime/references)
inline LayoutUnit& operator*=(LayoutUnit& a, float b) {
#ifdef _DEBUG
  int64_t value64 = a.value_;
#endif
  a.value_ = static_cast<int32_t>(floorf(static_cast<float>(a.value_) * b));
#ifdef _DEBUG
  a.is_nan_ = a.is_nan_ ||
              (a.value_ !=
               static_cast<int64_t>(floorf(static_cast<float>(value64) * b)));
#endif
  return a;
}

inline LayoutUnit operator*(LayoutUnit a, float b) { return a *= b; }

inline LayoutUnit operator*(float a, LayoutUnit b) { return b *= a; }

// NOLINTNEXTLINE(runtime/references)
inline LayoutUnit& operator/=(LayoutUnit& a, float b) {
  a.value_ = static_cast<int32_t>(floorf(static_cast<float>(a.value_) / b));
  return a;
}

inline LayoutUnit operator/(LayoutUnit a, float b) { return a /= b; }

inline std::ostream& operator<<(std::ostream& out, const LayoutUnit& x) {
#ifdef _DEBUG
  if (x.IsNaN()) {
    return out << "NaN(" << x.toFloat() << ")";
  }
#endif
  return out << x.toFloat();
}

}  // namespace layout
}  // namespace cobalt

#endif  // COBALT_LAYOUT_LAYOUT_UNIT_H_