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

#import "ios/chrome/browser/bubble/ui_bundled/bubble_util.h"

#import <ostream>

#import "base/check_op.h"
#import "base/i18n/rtl.h"
#import "base/notreached.h"
#import "ios/chrome/browser/bubble/ui_bundled/bubble_constants.h"
#import "ios/chrome/browser/shared/ui/util/rtl_geometry.h"

namespace {

// Bubble's maximum width, preserves readability, ensuring that the bubble does
// not span across wide screens.
const CGFloat kBubbleMaxWidth = 375.0f;

// Whether bubble with arrow direction `direction` is pointing left.
BOOL IsArrowPointingLeft(BubbleArrowDirection direction, bool is_rtl) {
  return direction ==
         (is_rtl ? BubbleArrowDirectionTrailing : BubbleArrowDirectionLeading);
}

// Calculate the distance from the bubble's leading edge to the leading edge of
// its bounding coordinate system. In LTR contexts, the returned float is the
// x-coordinate of the bubble's origin. This calculation is based on
// `anchor_point`, which is the point of the target UI element the bubble is
// anchored at, and the bubble's alignment offset, alignment, direction, and
// size. The returned float is in the same coordinate system as `anchor_point`,
// which should be the coordinate system in which the bubble is drawn.
CGFloat LeadingDistance(CGPoint anchor_point,
                        BubbleArrowDirection arrow_direction,
                        CGFloat bubble_alignment_offset,
                        BubbleAlignment alignment,
                        CGFloat bubble_width,
                        CGFloat bounding_width,
                        bool is_rtl) {
  // Find `leading_offset`, the distance from the bubble's leading edge to the
  // anchor point. This depends on alignment and bubble width.
  CGFloat leading_offset;
  switch (arrow_direction) {
    case BubbleArrowDirectionUp:
    case BubbleArrowDirectionDown:
      switch (alignment) {
        case BubbleAlignmentTopOrLeading:
          leading_offset = bubble_alignment_offset;
          break;
        case BubbleAlignmentCenter:
          leading_offset = bubble_width / 2.0f;
          break;
        case BubbleAlignmentBottomOrTrailing:
          leading_offset = bubble_width - bubble_alignment_offset;
          break;
        default:
          NOTREACHED() << "Invalid bubble alignment " << alignment;
      }
      break;
    case BubbleArrowDirectionLeading:
      leading_offset = 0;
      break;
    case BubbleArrowDirectionTrailing:
      leading_offset = bubble_width;
      break;
  }
  CGFloat leading_distance;
  if (is_rtl) {
    leading_distance = bounding_width - (anchor_point.x + leading_offset);
  } else {
    leading_distance = anchor_point.x - leading_offset;
  }
  // Ceil the leading distance because the max width was floored.
  return ceil(leading_distance);
}

// Calculate the y-coordinate of the bubble's origin based on `anchor_point`,
// the point of the UI element the bubble is anchored at, and the bubble's
// alignment offset, alignment, direction and size. The returned float is in the
// same coordinate system as `anchor_point`, which should be the coordinate
// system in which the bubble is drawn.
CGFloat OriginY(CGPoint anchor_point,
                BubbleArrowDirection arrow_direction,
                CGFloat bubble_alignment_offset,
                BubbleAlignment alignment,
                CGFloat bubble_height) {
  CGFloat origin_y;
  switch (arrow_direction) {
    case BubbleArrowDirectionUp:
      origin_y = anchor_point.y;
      break;
    case BubbleArrowDirectionDown:
      origin_y = anchor_point.y - bubble_height;
      break;
    case BubbleArrowDirectionLeading:
    case BubbleArrowDirectionTrailing:
      switch (alignment) {
        case BubbleAlignmentTopOrLeading:
          origin_y = anchor_point.y - bubble_alignment_offset;
          break;
        case BubbleAlignmentCenter:
          origin_y = anchor_point.y - bubble_height / 2;
          break;
        case BubbleAlignmentBottomOrTrailing:
          origin_y = anchor_point.y - (bubble_height - bubble_alignment_offset);
          break;
      }
      break;
  }
  // Ceil the originY because the max height was floored.
  return ceil(origin_y);
}

// Calculate the maximum width of the bubble such that it stays within its
// bounding coordinate space. `anchor_point_x` is the x-coordinate of the point
// on the target UI element the bubble is anchored at. It is in the coordinate
// system in which the bubble is drawn. `direction` is the direction the bubble
// arrow points to. `bubble_alignment_offset` is the distance from the leading
// edge of the bubble to the anchor point if leading aligned, and from the
// trailing edge of the bubble to the anchor point if trailing aligned.
// `alignment` is the bubble's alignment, `bounding_width` is the width of the
// coordinate space in which the bubble is drawn, and `is_rtl` is true if the
// language is RTL and `false` otherwise.
CGFloat BubbleMaxWidth(CGFloat anchor_point_x,
                       BubbleArrowDirection direction,
                       CGFloat bubble_alignment_offset,
                       BubbleAlignment alignment,
                       CGFloat bounding_width,
                       bool is_rtl) {
  CGFloat max_width;
  // Space on the left of the anchor point.
  CGFloat distance_to_left_edge = anchor_point_x;
  // Space on the right of the anchor point.
  CGFloat distance_to_right_edge = bounding_width - anchor_point_x;
  switch (direction) {
    case BubbleArrowDirectionUp:
    case BubbleArrowDirectionDown:
      switch (alignment) {
        case BubbleAlignmentTopOrLeading:
          // The bubble can use the space from the anchor point to the trailing
          // edge.
          max_width =
              (is_rtl ? distance_to_left_edge : distance_to_right_edge) +
              bubble_alignment_offset;
          break;
        case BubbleAlignmentCenter:
          // The width of half the bubble cannot exceed the distance from the
          // anchor point to the closest edge of the superview.
          max_width = MIN(distance_to_left_edge, distance_to_right_edge) * 2.0f;
          break;
        case BubbleAlignmentBottomOrTrailing:
          // The bubble can use the space from the anchor point to the leading
          // edge.
          max_width =
              (is_rtl ? distance_to_right_edge : distance_to_left_edge) +
              bubble_alignment_offset;
          break;
        default:
          NOTREACHED() << "Invalid bubble alignment " << alignment;
      }
      break;
    case BubbleArrowDirectionLeading:
    case BubbleArrowDirectionTrailing:
      if (IsArrowPointingLeft(direction, is_rtl)) {
        max_width = distance_to_right_edge;
      } else {
        max_width = distance_to_left_edge;
      }
      break;
  }
  // Floor the width to be conservative.
  return floor(MIN(max_width, kBubbleMaxWidth));
}

// Calculate the maximum height of the bubble such that it stays within its
// bounding coordinate space. `anchor_point_y` is the y-coordinate of the point
// on the target UI element the bubble is anchored at. It is in the coordinate
// system in which the bubble is drawn. `direction` is the direction the arrow
// is pointing. `bubble_alignment_offset` is the distance from the leading or
// top edge of the bubble to the anchor point if leading aligned, and from the
// bottom or trailing edge of the bubble to the anchor point if trailing
// aligned. `alignment` is the bubble's alignment, `bounding_height` is the
// height of the coordinate space in which the bubble is drawn.
CGFloat BubbleMaxHeight(CGFloat anchor_point_y,
                        BubbleArrowDirection direction,
                        CGFloat bubble_alignment_offset,
                        BubbleAlignment alignment,
                        CGFloat bounding_height) {
  CGFloat max_height;
  // Space on the top of the anchor point.
  CGFloat distance_to_top_edge = anchor_point_y;
  // Space on the bottom of the anchor point.
  CGFloat distance_to_bottom_edge = bounding_height - anchor_point_y;
  switch (direction) {
    case BubbleArrowDirectionUp:
      max_height = distance_to_bottom_edge;
      break;
    case BubbleArrowDirectionDown:
      max_height = distance_to_top_edge;
      break;
    case BubbleArrowDirectionLeading:
    case BubbleArrowDirectionTrailing:
      switch (alignment) {
        case BubbleAlignmentTopOrLeading:
          // The bubble can use the space from the anchor point to the bottom
          // edge.
          max_height = distance_to_bottom_edge + bubble_alignment_offset;
          break;
        case BubbleAlignmentCenter:
          // The height of half the bubble cannot exceed the distance from the
          // anchor point to the closest edge of the superview.
          max_height =
              MIN(distance_to_top_edge, distance_to_bottom_edge) * 2.0f;
          break;
        case BubbleAlignmentBottomOrTrailing:
          // The bubble can use the space from the anchor point to the top
          // edge.
          max_height = distance_to_top_edge + bubble_alignment_offset;
          break;
      }
      break;
  }
  // Floor the height to be conservative.
  return floor(max_height);
}

}  // namespace

namespace bubble_util {

CGFloat BubbleDefaultAlignmentOffset() {
  // This is used to replace a constant that would change based on the flag.
  return 29;
}

CGPoint AnchorPoint(CGRect target_frame, BubbleArrowDirection arrow_direction) {
  CGPoint anchor_point;
  bool is_rtl = base::i18n::IsRTL();
  switch (arrow_direction) {
    case BubbleArrowDirectionUp:
      anchor_point.x = CGRectGetMidX(target_frame);
      anchor_point.y = CGRectGetMaxY(target_frame);
      break;
    case BubbleArrowDirectionDown:
      anchor_point.x = CGRectGetMidX(target_frame);
      anchor_point.y = CGRectGetMinY(target_frame);
      break;
    case BubbleArrowDirectionLeading:
    case BubbleArrowDirectionTrailing:
      anchor_point.x = IsArrowPointingLeft(arrow_direction, is_rtl)
                           ? CGRectGetMaxX(target_frame)
                           : CGRectGetMinX(target_frame);
      anchor_point.y = CGRectGetMidY(target_frame);
      break;
  }
  return anchor_point;
}

// Calculate the maximum size of the bubble such that it stays within its
// superview's bounding coordinate space and does not overlap the other side of
// the anchor point. `anchor_point` is the point on the target UI element the
// bubble is anchored at in the bubble's superview's coordinate system.
// `bubble_alignment_offset` is the distance from the leading edge of the bubble
// to the anchor point if leading aligned, and from the trailing edge of the
// bubble to the anchor point if trailing aligned. `direction` is the bubble's
// direction. `alignment` is the bubble's alignment. `bounding_size` is the size
// of the superview. `is_rtl` is `true` if the coordinates are in right-to-left
// language coordinates and `false` otherwise. This method is unit tested so it
// cannot be in the above anonymous namespace.
CGSize BubbleMaxSize(CGPoint anchor_point,
                     CGFloat bubble_alignment_offset,
                     BubbleArrowDirection direction,
                     BubbleAlignment alignment,
                     CGSize bounding_size,
                     bool is_rtl) {
  CGFloat max_width =
      BubbleMaxWidth(anchor_point.x, direction, bubble_alignment_offset,
                     alignment, bounding_size.width, is_rtl);
  CGFloat max_height =
      BubbleMaxHeight(anchor_point.y, direction, bubble_alignment_offset,
                      alignment, bounding_size.height);
  return CGSizeMake(max_width, max_height);
}

CGSize BubbleMaxSize(CGPoint anchor_point,
                     CGFloat bubble_alignment_offset,
                     BubbleArrowDirection direction,
                     BubbleAlignment alignment,
                     CGSize bounding_size) {
  bool is_rtl = base::i18n::IsRTL();
  return BubbleMaxSize(anchor_point, bubble_alignment_offset, direction,
                       alignment, bounding_size, is_rtl);
}

// Calculate the bubble's frame. `anchor_point` is the point on the UI element
// the bubble is pointing to. `bubble_alignment_offset` is the distance from the
// leading edge of the bubble to the anchor point if leading aligned, and from
// the trailing edge of the bubble to the anchor point if trailing aligned.
// `size` is the size of the bubble. `direction` is the direction the bubble's
// arrow is pointing. `alignment` is the alignment of the anchor (either
// leading, centered, or trailing). `bounding_width` is the width of the
// bubble's superview. `is_rtl` is `true` if the coordinates are in
// right-to-left language coordinates and `false` otherwise. This method is unit
// tested so it cannot be in the above anonymous namespace.
CGRect BubbleFrame(CGPoint anchor_point,
                   CGFloat bubble_alignment_offset,
                   CGSize size,
                   BubbleArrowDirection direction,
                   BubbleAlignment alignment,
                   CGFloat bounding_width,
                   bool is_rtl) {
  CGFloat leading =
      LeadingDistance(anchor_point, direction, bubble_alignment_offset,
                      alignment, size.width, bounding_width, is_rtl);
  CGFloat origin_y = OriginY(anchor_point, direction, bubble_alignment_offset,
                             alignment, size.height);
  // Use a `LayoutRect` to ensure that the bubble is mirrored in RTL contexts.
  base::i18n::TextDirection textDirection =
      is_rtl ? base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
  CGRect bubble_frame = LayoutRectGetRectUsingDirection(
      LayoutRectMake(leading, bounding_width, origin_y, size.width,
                     size.height),
      textDirection);
  return bubble_frame;
}

CGRect BubbleFrame(CGPoint anchor_point,
                   CGFloat bubble_alignment_offset,
                   CGSize size,
                   BubbleArrowDirection direction,
                   BubbleAlignment alignment,
                   CGFloat bounding_width) {
  bool is_rtl = base::i18n::IsRTL();
  return BubbleFrame(anchor_point, bubble_alignment_offset, size, direction,
                     alignment, bounding_width, is_rtl);
}

CGFloat FloatingArrowAlignmentOffset(CGFloat bounding_width,
                                     CGPoint anchor_point,
                                     BubbleAlignment alignment) {
  CGFloat alignment_offset;
  BOOL is_rtl = base::i18n::IsRTL();
  // TODO(crbug.com/40276959): Leading and trailing direction.
  switch (alignment) {
    case BubbleAlignmentTopOrLeading:
      alignment_offset =
          is_rtl ? bounding_width - anchor_point.x : anchor_point.x;
      break;
    case BubbleAlignmentCenter:
      alignment_offset = 0.0f;  // value is ignored when laying out the arrow.
      break;
    case BubbleAlignmentBottomOrTrailing:
      alignment_offset =
          is_rtl ? anchor_point.x : bounding_width - anchor_point.x;
      break;
  }
  // Alignment offset must be greater than `BubbleDefaultAlignmentOffset` to
  // make sure the arrow is in the frame of the background of the bubble. The
  // maximum is set to the middle of the bubble so the arrow stays close to the
  // leading edge when using a leading alignment.
  return MAX(MIN(kBubbleMaxWidth / 2, alignment_offset),
             BubbleDefaultAlignmentOffset());
}

}  // namespace bubble_util
