// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/utility/arc_curve_path_util.h"

#include <optional>

#include "base/check_op.h"
#include "base/logging.h"
#include "third_party/skia/include/core/SkPath.h"
#include "third_party/skia/include/core/SkPathBuilder.h"
#include "third_party/skia/include/core/SkPoint.h"
#include "ui/gfx/geometry/size.h"

namespace ash::util {

namespace {

// Aliases ---------------------------------------------------------------------

using CornerLocation = ArcCurveCorner::CornerLocation;

// Helpers ---------------------------------------------------------------------

// Returns the corner point specified by `location` on the bounding rectangle
// of `size`.
SkPoint GetCornerPoint(const gfx::Size& size, CornerLocation location) {
  bool at_left = false;
  switch (location) {
    case CornerLocation::kBottomLeft:
    case CornerLocation::kTopLeft:
      at_left = true;
      break;
    case CornerLocation::kBottomRight:
    case CornerLocation::kTopRight:
      at_left = false;
      break;
  }

  bool at_bottom = false;
  switch (location) {
    case CornerLocation::kBottomLeft:
    case CornerLocation::kBottomRight:
      at_bottom = true;
      break;
    case CornerLocation::kTopLeft:
    case CornerLocation::kTopRight:
      at_bottom = false;
      break;
  }

  return SkPoint::Make(at_left ? 0 : size.width(),
                       at_bottom ? size.height() : 0);
}

// Returns the next corner counterclockwise from `corner`.
CornerLocation GetNextCorner(CornerLocation corner) {
  return corner == CornerLocation::kMax
             ? CornerLocation::kMin
             : static_cast<CornerLocation>(static_cast<size_t>(corner) + 1);
}

// Returns the previous corner counterclockwise from `corner`.
CornerLocation GetPrevCorner(CornerLocation corner) {
  return corner == CornerLocation::kMin
             ? CornerLocation::kMax
             : static_cast<CornerLocation>(static_cast<size_t>(corner) - 1);
}

bool IsSizeAndCornerRadiusValid(const gfx::Size& size,
                                const std::optional<size_t>& corner_radius) {
  if (size.IsEmpty()) {
    LOG(ERROR) << "GetArcCurveRectPath() is called with an empty size: "
               << size.ToString();
    return false;
  }

  if (corner_radius &&
      (2 * corner_radius.value() >
       static_cast<size_t>(std::min(size.width(), size.height())))) {
    LOG(ERROR) << "GetArcCurveRectPath() is called with a size that is too "
                  "small for rounded corners; the size: "
               << size.ToString() << ", corner radius: " << *corner_radius;

    return false;
  }

  return true;
}

}  // namespace

// ArcCurveCorner --------------------------------------------------------------

ArcCurveCorner::ArcCurveCorner(CornerLocation location,
                               const gfx::Size& size,
                               float concave_radius,
                               float convex_radius)
    : location(location),
      size(size),
      concave_radius(concave_radius),
      convex_radius(convex_radius) {
  CHECK_LE(convex_radius * 2 + concave_radius, size.width());
  CHECK_LE(convex_radius * 2 + concave_radius, size.height());
}

// Utils -----------------------------------------------------------------------

SkPath GetArcCurveRectPath(const gfx::Size& size, const size_t corner_radius) {
  if (!IsSizeAndCornerRadiusValid(size, corner_radius)) {
    return SkPath();
  }

  const auto width = size.width();
  const auto height = size.height();

  const auto bottom_left = SkPoint::Make(0.f, height);
  const auto bottom_right = SkPoint::Make(width, height);
  const auto top_right = SkPoint::Make(width, 0.f);
  const auto top_left = SkPoint::Make(0.f, 0.f);

  // One-radius offsets that can be added to or subtracted from coordinates to
  // indicate a unidirectional move, e.g., when calculating the endpoint of an
  // arc.
  const auto horizontal_offset = SkPoint::Make(corner_radius, 0.f);
  const auto vertical_offset = SkPoint::Make(0.f, corner_radius);

  return SkPathBuilder()
      // Start just after the curve of the top-left rounded corner.
      .moveTo(0.f, corner_radius)
      .arcTo(bottom_left, bottom_left + horizontal_offset, corner_radius)
      .arcTo(bottom_right, bottom_right - vertical_offset, corner_radius)
      .arcTo(top_right, top_right - horizontal_offset, corner_radius)
      .arcTo(top_left, top_left + vertical_offset, corner_radius)
      .close()
      .detach();
}

SkPath GetArcCurveRectPath(const gfx::Size& size,
                           const ArcCurveCorner& arc_curve_corner,
                           const std::optional<size_t>& corner_radius) {
  if (!IsSizeAndCornerRadiusValid(size, corner_radius)) {
    return SkPath();
  }

  if (const gfx::Size& arc_corner_size = arc_curve_corner.size;
      size.height() < arc_corner_size.height() ||
      size.width() < arc_corner_size.width()) {
    LOG(ERROR) << "GetArcCurveRectPath() is called with a size that is too "
                  "small for the arc curve corner; the size: "
               << size.ToString() << ", arc_curve_corner size: "
               << arc_curve_corner.size.ToString();

    return SkPath();
  }

  // Iterate all corners counterclockwise, starting from the top left corner.
  // Therefore, the total iteration count should be 4.
  SkPathBuilder builder;
  CornerLocation current_corner = CornerLocation::kMin;
  for (size_t iteration_index = 0; iteration_index < 4; ++iteration_index) {
    const SkPoint current_corner_point = GetCornerPoint(size, current_corner);

    // Calculate the normalized vector from the previous corner counterclockwise
    // to `current_corner`. For example, if `current_corner` is the top left
    // one, this vector should be (-1, 0).
    SkVector prev_to_current_normalized_offset =
        current_corner_point -
        GetCornerPoint(size, GetPrevCorner(current_corner));
    SkVector::Normalize(&prev_to_current_normalized_offset);

    const bool is_arc_curve = current_corner == arc_curve_corner.location;

    // Calculate the starting point of the path for `current_corner`.
    const SkVector start_offset =
        SkVector::Make(prev_to_current_normalized_offset.x() *
                           (is_arc_curve ? arc_curve_corner.size.width()
                                         : corner_radius.value_or(0)),
                       prev_to_current_normalized_offset.y() *
                           (is_arc_curve ? arc_curve_corner.size.height()
                                         : corner_radius.value_or(0)));
    const SkPoint corner_path_start = current_corner_point - start_offset;

    if (builder.snapshot().isEmpty()) {
      builder.moveTo(corner_path_start);
    } else {
      builder.lineTo(corner_path_start);
    }

    // Calculate the normalized vector from `current_corner` to the next corner
    // counterclockwise. For example, if `current_corner` is the top left one,
    // this vector should be (0, 1).
    SkVector current_to_next_normalized_offset =
        GetCornerPoint(size, GetNextCorner(current_corner)) -
        current_corner_point;
    SkVector::Normalize(&current_to_next_normalized_offset);

    const SkVector offset_sum =
        prev_to_current_normalized_offset + current_to_next_normalized_offset;

    // Calculate the remaining offset after excluding the spacing required by
    // the convex radius and the concave radius.
    const float radius_sum_spacing =
        2 * arc_curve_corner.convex_radius + arc_curve_corner.concave_radius;
    const auto extra_spacing_offset =
        SkVector::Make(arc_curve_corner.size.width(),
                       arc_curve_corner.size.height()) -
        SkVector::Make(radius_sum_spacing, radius_sum_spacing);

    if (is_arc_curve) {
      // Draw the first convex curve.
      SkPoint arc1 = corner_path_start + prev_to_current_normalized_offset *
                                             arc_curve_corner.convex_radius;
      SkPoint arc2 =
          corner_path_start + offset_sum * arc_curve_corner.convex_radius;
      builder.arcTo(arc1, arc2, arc_curve_corner.convex_radius);

      // Draw the extra spacing.
      arc2 = arc2 + SkVector::Make(extra_spacing_offset.x() *
                                       current_to_next_normalized_offset.x(),
                                   extra_spacing_offset.y() *
                                       current_to_next_normalized_offset.y());
      builder.lineTo(arc2);

      // Draw the concave curve.
      SkPoint last_point = arc2;
      arc1 = last_point + current_to_next_normalized_offset *
                              arc_curve_corner.concave_radius;
      arc2 = last_point + offset_sum * arc_curve_corner.concave_radius;
      builder.arcTo(arc1, arc2, arc_curve_corner.concave_radius);

      // Draw the extra spacing.
      last_point = arc2;
      arc2 =
          last_point +
          SkVector::Make(
              extra_spacing_offset.x() * prev_to_current_normalized_offset.x(),
              extra_spacing_offset.y() * prev_to_current_normalized_offset.y());
      builder.lineTo(arc2);

      // Draw the second convex curve.
      last_point = arc2;
      arc1 = last_point +
             prev_to_current_normalized_offset * arc_curve_corner.convex_radius;
      arc2 = last_point + offset_sum * arc_curve_corner.convex_radius;
      builder.arcTo(arc1, arc2, arc_curve_corner.convex_radius);
    } else if (corner_radius) {
      const SkPoint arc1 =
          corner_path_start +
          prev_to_current_normalized_offset * corner_radius.value();
      const SkPoint arc2 =
          corner_path_start + offset_sum * corner_radius.value();
      builder.arcTo(arc1, arc2, corner_radius.value());
    }

    if (current_corner == CornerLocation::kMax) {
      builder.close();
    } else {
      current_corner = GetNextCorner(current_corner);
    }
  }

  return builder.detach();
}

}  // namespace ash::util