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

#include "third_party/blink/renderer/core/intersection_observer/intersection_geometry.h"

#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/local_frame_view.h"
#include "third_party/blink/renderer/core/frame/settings.h"
#include "third_party/blink/renderer/core/html/html_frame_owner_element.h"
#include "third_party/blink/renderer/core/intersection_observer/intersection_observer_entry.h"
#include "third_party/blink/renderer/core/layout/adjust_for_absolute_zoom.h"
#include "third_party/blink/renderer/core/layout/layout_box.h"
#include "third_party/blink/renderer/core/layout/layout_embedded_content.h"
#include "third_party/blink/renderer/core/layout/layout_inline.h"
#include "third_party/blink/renderer/core/layout/layout_view.h"
#include "third_party/blink/renderer/core/page/page.h"
#include "third_party/blink/renderer/core/paint/paint_layer.h"

namespace blink {

namespace {

bool IsContainingBlockChainDescendant(LayoutObject* descendant,
                                      LayoutObject* ancestor) {
  LocalFrame* ancestor_frame = ancestor->GetDocument().GetFrame();
  LocalFrame* descendant_frame = descendant->GetDocument().GetFrame();
  if (ancestor_frame != descendant_frame)
    return false;

  while (descendant && descendant != ancestor)
    descendant = descendant->ContainingBlock();
  return descendant;
}

void MapRectUpToDocument(LayoutRect& rect, const LayoutObject& descendant) {
  FloatQuad mapped_quad =
      descendant.LocalToAncestorQuad(FloatQuad(FloatRect(rect)), nullptr,
                                     kUseTransforms | kApplyContainerFlip);
  rect = LayoutRect(mapped_quad.BoundingBox());
}

void MapRectDownToDocument(LayoutRect& rect,
                           const Document& document) {
  FloatQuad mapped_quad = document.GetLayoutView()->AncestorToLocalQuad(
      nullptr, FloatQuad(FloatRect(rect)),
      kUseTransforms | kApplyContainerFlip | kTraverseDocumentBoundaries);
  rect = LayoutRect(mapped_quad.BoundingBox());
}

LayoutUnit ComputeMargin(const Length& length, LayoutUnit reference_length) {
  if (length.IsPercent()) {
    return LayoutUnit(static_cast<int>(reference_length.ToFloat() *
                                       length.Percent() / 100.0));
  }
  DCHECK(length.IsFixed());
  return LayoutUnit(length.IntValue());
}

LayoutView* LocalRootView(Element& element) {
  LocalFrame* frame = element.GetDocument().GetFrame();
  LocalFrame* frame_root = frame ? &frame->LocalFrameRoot() : nullptr;
  return frame_root ? frame_root->ContentLayoutObject() : nullptr;
}

bool ComputeIsVisible(LayoutObject* target, const LayoutRect& rect) {
  DCHECK(RuntimeEnabledFeatures::IntersectionObserverV2Enabled());
  if (target->GetDocument().GetFrame()->LocalFrameRoot().GetOcclusionState() !=
      FrameOcclusionState::kGuaranteedNotOccluded) {
    return false;
  }
  if (target->HasDistortingVisualEffects())
    return false;
  // TODO(layout-dev): This should hit-test the intersection rect, not the
  // target rect; it's not helpful to know that the portion of the target that
  // is clipped is also occluded.
  HitTestResult result(target->HitTestForOcclusion(rect));
  return (!result.InnerNode() || result.InnerNode() == target->GetNode());
}

static const unsigned kConstructorFlagsMask =
    IntersectionGeometry::kShouldReportRootBounds |
    IntersectionGeometry::kShouldComputeVisibility |
    IntersectionGeometry::kShouldTrackFractionOfRoot |
    IntersectionGeometry::kShouldUseReplacedContentRect |
    IntersectionGeometry::kShouldConvertToCSSPixels;

}  // namespace

IntersectionGeometry::IntersectionGeometry(Element* root_element,
                                           Element& target_element,
                                           const Vector<Length>& root_margin,
                                           const Vector<float>& thresholds,
                                           unsigned flags)
    : flags_(flags & kConstructorFlagsMask),
      intersection_ratio_(0),
      threshold_index_(0) {
  DCHECK(root_margin.IsEmpty() || root_margin.size() == 4);
  ComputeGeometry(root_element, target_element, root_margin, thresholds);
}

IntersectionGeometry::~IntersectionGeometry() = default;

void IntersectionGeometry::ComputeGeometry(Element* root_element,
                                           Element& target_element,
                                           const Vector<Length>& root_margin,
                                           const Vector<float>& thresholds) {
  LayoutObject* target = target_element.GetLayoutObject();
  LayoutObject* root;
  if (root_element) {
    root = root_element->GetLayoutObject();
    flags_ &= ~kRootIsImplicit;
  } else {
    root = LocalRootView(target_element);
    flags_ |= kRootIsImplicit;
  }
  if (!target_element.isConnected())
    return;
  if (root_element && !root_element->isConnected())
    return;
  if (!root || !root->IsBox())
    return;
  if (!target || (!target->IsBoxModelObject() && !target->IsText()))
    return;
  if (root_element && !IsContainingBlockChainDescendant(target, root))
    return;

  DCHECK(!target_element.GetDocument().View()->NeedsLayout());

  target_rect_ = InitializeTargetRect(target);
  intersection_rect_ = target_rect_;
  root_rect_ = InitializeRootRect(root, root_margin);
  bool does_intersect =
      ClipToRoot(root, target, root_rect_, intersection_rect_);
  MapRectUpToDocument(target_rect_, *target);
  if (does_intersect) {
    if (RootIsImplicit())
      MapRectDownToDocument(intersection_rect_, target->GetDocument());
    else
      MapRectUpToDocument(intersection_rect_, *root);
  } else {
    intersection_rect_ = LayoutRect();
  }
  MapRectUpToDocument(root_rect_, *root);

  // Some corner cases for threshold index:
  //   - If target rect is zero area, because it has zero width and/or zero
  //     height,
  //     only two states are recognized:
  //     - 0 means not intersecting.
  //     - 1 means intersecting.
  //     No other threshold crossings are possible.
  //   - Otherwise:
  //     - If root and target do not intersect, the threshold index is 0.

  //     - If root and target intersect but the intersection has zero-area
  //       (i.e., they have a coincident edge or corner), we consider the
  //       intersection to have "crossed" a zero threshold, but not crossed
  //       any non-zero threshold.

  if (does_intersect) {
    const LayoutRect comparison_rect =
        ShouldTrackFractionOfRoot() ? root_rect_ : target_rect_;
    if (comparison_rect.IsEmpty()) {
      intersection_ratio_ = 1;
    } else {
      const LayoutSize& intersection_size = intersection_rect_.Size();
      const float intersection_area = intersection_size.Width().ToFloat() *
                                      intersection_size.Height().ToFloat();
      const LayoutSize& comparison_size = comparison_rect.Size();
      const float area_of_interest = comparison_size.Width().ToFloat() *
                                     comparison_size.Height().ToFloat();
      intersection_ratio_ = intersection_area / area_of_interest;
    }
    threshold_index_ =
        FirstThresholdGreaterThan(intersection_ratio_, thresholds);
  } else {
    intersection_ratio_ = 0;
    threshold_index_ = 0;
  }
  if (IsIntersecting() && ShouldComputeVisibility() &&
      ComputeIsVisible(target, target_rect_))
    flags_ |= kIsVisible;

  if (flags_ & kShouldConvertToCSSPixels) {
    FloatRect target_float_rect(target_rect_);
    AdjustForAbsoluteZoom::AdjustFloatRect(target_float_rect, *target);
    target_rect_ = LayoutRect(target_float_rect);
    FloatRect intersection_float_rect(intersection_rect_);
    AdjustForAbsoluteZoom::AdjustFloatRect(intersection_float_rect, *target);
    intersection_rect_ = LayoutRect(intersection_float_rect);
    FloatRect root_float_rect(root_rect_);
    AdjustForAbsoluteZoom::AdjustFloatRect(root_float_rect, *root);
    root_rect_ = LayoutRect(root_float_rect);
  }
}

LayoutRect IntersectionGeometry::InitializeTargetRect(LayoutObject* target) {
  if ((flags_ & kShouldUseReplacedContentRect) &&
      target->IsLayoutEmbeddedContent()) {
    return ToLayoutEmbeddedContent(target)->ReplacedContentRect();
  }
  if (target->IsBox())
    return LayoutRect(ToLayoutBoxModelObject(target)->BorderBoundingBox());
  if (target->IsLayoutInline())
    return ToLayoutInline(target)->LinesBoundingBox();
  return ToLayoutText(target)->LinesBoundingBox();
}

LayoutRect IntersectionGeometry::InitializeRootRect(
    LayoutObject* root,
    const Vector<Length>& margin) {
  LayoutRect result;
  if (root->IsLayoutView() && root->GetDocument().IsInMainFrame()) {
    // The main frame is a bit special as the scrolling viewport can differ in
    // size from the LayoutView itself. There's two situations this occurs in:
    // 1) The ForceZeroLayoutHeight quirk setting is used in Android WebView for
    // compatibility and sets the initial-containing-block's (a.k.a.
    // LayoutView) height to 0. Thus, we can't use its size for intersection
    // testing. Use the FrameView geometry instead.
    // 2) An element wider than the ICB can cause us to resize the FrameView so
    // we can zoom out to fit the entire element width.
    result = ToLayoutView(root)->OverflowClipRect(LayoutPoint());
  } else if (root->IsBox() && root->HasOverflowClip()) {
    result = LayoutRect(ToLayoutBox(root)->PhysicalContentBoxRect());
  } else {
    result = LayoutRect(ToLayoutBoxModelObject(root)->BorderBoundingBox());
  }
  ApplyRootMargin(result, margin);
  return result;
}

void IntersectionGeometry::ApplyRootMargin(LayoutRect& rect,
                                           const Vector<Length>& margin) {
  if (margin.IsEmpty())
    return;

  // TODO(szager): Make sure the spec is clear that left/right margins are
  // resolved against width and not height.
  LayoutUnit top_margin = ComputeMargin(margin[0], rect.Height());
  LayoutUnit right_margin = ComputeMargin(margin[1], rect.Width());
  LayoutUnit bottom_margin = ComputeMargin(margin[2], rect.Height());
  LayoutUnit left_margin = ComputeMargin(margin[3], rect.Width());

  rect.SetX(rect.X() - left_margin);
  rect.SetWidth(rect.Width() + left_margin + right_margin);
  rect.SetY(rect.Y() - top_margin);
  rect.SetHeight(rect.Height() + top_margin + bottom_margin);
}

bool IntersectionGeometry::ClipToRoot(LayoutObject* root,
                                      LayoutObject* target,
                                      const LayoutRect& root_rect,
                                      LayoutRect& intersection_rect) {
  // Map and clip rect into root element coordinates.
  // TODO(szager): the writing mode flipping needs a test.
  LayoutBox* local_ancestor = nullptr;
  if (!RootIsImplicit() || root->GetDocument().IsInMainFrame())
    local_ancestor = ToLayoutBox(root);

  LayoutView* layout_view = target->GetDocument().GetLayoutView();

  unsigned flags = kDefaultVisualRectFlags | kEdgeInclusive;
  if (!layout_view->NeedsPaintPropertyUpdate() &&
      !layout_view->DescendantNeedsPaintPropertyUpdate()) {
    flags |= kUseGeometryMapper;
  }
  bool does_intersect = target->MapToVisualRectInAncestorSpace(
      local_ancestor, intersection_rect, static_cast<VisualRectFlags>(flags));
  if (!does_intersect || !local_ancestor)
    return does_intersect;
  if (local_ancestor->HasOverflowClip())
    intersection_rect.Move(-local_ancestor->ScrolledContentOffset());
  LayoutRect root_clip_rect(root_rect);
  local_ancestor->FlipForWritingMode(root_clip_rect);
  return does_intersect & intersection_rect.InclusiveIntersect(root_clip_rect);
}

unsigned IntersectionGeometry::FirstThresholdGreaterThan(
    float ratio,
    const Vector<float>& thresholds) const {
  unsigned result = 0;
  while (result < thresholds.size() && thresholds[result] <= ratio)
    ++result;
  return result;
}

}  // namespace blink