/*
 * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_FLOAT_ROUNDED_RECT_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_FLOAT_ROUNDED_RECT_H_

#include <iosfwd>
#include "third_party/blink/renderer/platform/geometry/float_rect.h"
#include "third_party/blink/renderer/platform/geometry/float_size.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
#include "third_party/skia/include/core/SkRRect.h"

namespace blink {

class FloatQuad;

class PLATFORM_EXPORT FloatRoundedRect {
  DISALLOW_NEW();

 public:
  class PLATFORM_EXPORT Radii {
    DISALLOW_NEW();

   public:
    constexpr Radii() = default;
    constexpr Radii(const FloatSize& top_left,
                    const FloatSize& top_right,
                    const FloatSize& bottom_left,
                    const FloatSize& bottom_right)
        : top_left_(top_left),
          top_right_(top_right),
          bottom_left_(bottom_left),
          bottom_right_(bottom_right) {}

    constexpr Radii(const FloatRoundedRect::Radii& int_radii)
        : top_left_(int_radii.TopLeft()),
          top_right_(int_radii.TopRight()),
          bottom_left_(int_radii.BottomLeft()),
          bottom_right_(int_radii.BottomRight()) {}

    void SetTopLeft(const FloatSize& size) { top_left_ = size; }
    void SetTopRight(const FloatSize& size) { top_right_ = size; }
    void SetBottomLeft(const FloatSize& size) { bottom_left_ = size; }
    void SetBottomRight(const FloatSize& size) { bottom_right_ = size; }
    constexpr const FloatSize& TopLeft() const { return top_left_; }
    constexpr const FloatSize& TopRight() const { return top_right_; }
    constexpr const FloatSize& BottomLeft() const { return bottom_left_; }
    constexpr const FloatSize& BottomRight() const { return bottom_right_; }

    constexpr bool IsZero() const {
      return top_left_.IsZero() && top_right_.IsZero() &&
             bottom_left_.IsZero() && bottom_right_.IsZero();
    }

    void Scale(float factor);
    // Multiply all radii by |factor| and floor the result to the nearest
    // integer.
    void ScaleAndFloor(float factor);

    void Expand(float top_width,
                float bottom_width,
                float left_width,
                float right_width);
    void Expand(float size) { Expand(size, size, size, size); }

    void Shrink(float top_width,
                float bottom_width,
                float left_width,
                float right_width);
    void Shrink(float size) { Shrink(size, size, size, size); }

    String ToString() const;

   private:
    FloatSize top_left_;
    FloatSize top_right_;
    FloatSize bottom_left_;
    FloatSize bottom_right_;
  };

  constexpr FloatRoundedRect() = default;
  explicit FloatRoundedRect(const FloatRect&, const Radii& = Radii());
  explicit FloatRoundedRect(const IntRect&, const Radii& = Radii());
  FloatRoundedRect(float x, float y, float width, float height);
  FloatRoundedRect(const FloatRect&,
                   const FloatSize& top_left,
                   const FloatSize& top_right,
                   const FloatSize& bottom_left,
                   const FloatSize& bottom_right);

  constexpr const FloatRect& Rect() const { return rect_; }
  constexpr const Radii& GetRadii() const { return radii_; }
  constexpr bool IsRounded() const { return !radii_.IsZero(); }
  constexpr bool IsEmpty() const { return rect_.IsEmpty(); }

  void SetRect(const FloatRect& rect) { rect_ = rect; }
  void SetRadii(const Radii& radii) { radii_ = radii; }

  void Move(const FloatSize& size) { rect_.Move(size); }
  void InflateWithRadii(int size);
  void Inflate(float size) { rect_.Inflate(size); }

  // expandRadii() does not have any effect on corner radii which have zero
  // width or height. This is because the process of expanding the radius of a
  // corner is not allowed to make sharp corners non-sharp. This applies when
  // "spreading" a shadow or a box shape.
  void ExpandRadii(float size) { radii_.Expand(size); }
  void ShrinkRadii(float size) { radii_.Shrink(size); }

  // Returns a quickly computed rect enclosed by the rounded rect.
  FloatRect RadiusCenterRect() const;

  constexpr FloatRect TopLeftCorner() const {
    return FloatRect(rect_.X(), rect_.Y(), radii_.TopLeft().Width(),
                     radii_.TopLeft().Height());
  }
  constexpr FloatRect TopRightCorner() const {
    return FloatRect(rect_.MaxX() - radii_.TopRight().Width(), rect_.Y(),
                     radii_.TopRight().Width(), radii_.TopRight().Height());
  }
  constexpr FloatRect BottomLeftCorner() const {
    return FloatRect(rect_.X(), rect_.MaxY() - radii_.BottomLeft().Height(),
                     radii_.BottomLeft().Width(), radii_.BottomLeft().Height());
  }
  constexpr FloatRect BottomRightCorner() const {
    return FloatRect(rect_.MaxX() - radii_.BottomRight().Width(),
                     rect_.MaxY() - radii_.BottomRight().Height(),
                     radii_.BottomRight().Width(),
                     radii_.BottomRight().Height());
  }

  bool XInterceptsAtY(float y,
                      float& min_x_intercept,
                      float& max_x_intercept) const;

  // Tests whether the quad intersects any part of this rounded rectangle.
  // This only works for convex quads.
  // This intersection is edge-inclusive and will return true even if the
  // intersecting area is empty (i.e., the intersection is a line or a point).
  bool IntersectsQuad(const FloatQuad&) const;

  void AdjustRadii();
  bool IsRenderable() const;

  // Constrains the radii to be no more than the size of rect(); radii outside
  // of this range are not defined.  In addition, the radii of the corners are
  // floored to the nearest integer.
  // FIXME: the flooring should not be necessary. At the moment it causes
  // background bleed in some cases.
  // FIXME: this code is almost the same as adjustRadii()/isRenderable(). Get
  // rid of one of them.
  void ConstrainRadii();

  operator SkRRect() const;

  String ToString() const;

 private:
  FloatRect rect_;
  Radii radii_;
};

inline FloatRoundedRect::operator SkRRect() const {
  SkRRect rrect;

  if (IsRounded()) {
    SkVector radii[4];
    radii[SkRRect::kUpperLeft_Corner].set(TopLeftCorner().Width(),
                                          TopLeftCorner().Height());
    radii[SkRRect::kUpperRight_Corner].set(TopRightCorner().Width(),
                                           TopRightCorner().Height());
    radii[SkRRect::kLowerRight_Corner].set(BottomRightCorner().Width(),
                                           BottomRightCorner().Height());
    radii[SkRRect::kLowerLeft_Corner].set(BottomLeftCorner().Width(),
                                          BottomLeftCorner().Height());

    rrect.setRectRadii(Rect(), radii);
  } else {
    rrect.setRect(Rect());
  }

  return rrect;
}

constexpr bool operator==(const FloatRoundedRect::Radii& a,
                          const FloatRoundedRect::Radii& b) {
  return a.TopLeft() == b.TopLeft() && a.TopRight() == b.TopRight() &&
         a.BottomLeft() == b.BottomLeft() && a.BottomRight() == b.BottomRight();
}

constexpr bool operator!=(const FloatRoundedRect::Radii& a,
                          const FloatRoundedRect::Radii& b) {
  return !(a == b);
}

constexpr bool operator==(const FloatRoundedRect& a,
                          const FloatRoundedRect& b) {
  return a.Rect() == b.Rect() && a.GetRadii() == b.GetRadii();
}

constexpr bool operator!=(const FloatRoundedRect& a,
                          const FloatRoundedRect& b) {
  return !(a == b);
}

PLATFORM_EXPORT std::ostream& operator<<(std::ostream&,
                                         const FloatRoundedRect&);
PLATFORM_EXPORT std::ostream& operator<<(std::ostream&,
                                         const FloatRoundedRect::Radii&);

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_GEOMETRY_FLOAT_ROUNDED_RECT_H_