// Copyright 2014 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/paint/svg_shape_painter.h"

#include "base/optional.h"
#include "third_party/blink/renderer/core/layout/svg/layout_svg_resource_marker.h"
#include "third_party/blink/renderer/core/layout/svg/layout_svg_shape.h"
#include "third_party/blink/renderer/core/layout/svg/svg_layout_support.h"
#include "third_party/blink/renderer/core/layout/svg/svg_marker_data.h"
#include "third_party/blink/renderer/core/layout/svg/svg_resources.h"
#include "third_party/blink/renderer/core/layout/svg/svg_resources_cache.h"
#include "third_party/blink/renderer/core/paint/paint_info.h"
#include "third_party/blink/renderer/core/paint/svg_container_painter.h"
#include "third_party/blink/renderer/core/paint/svg_model_object_painter.h"
#include "third_party/blink/renderer/core/paint/svg_paint_context.h"
#include "third_party/blink/renderer/platform/graphics/graphics_context_state_saver.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h"
#include "third_party/blink/renderer/platform/graphics/paint/paint_record.h"
#include "third_party/blink/renderer/platform/graphics/paint/paint_record_builder.h"

namespace blink {

static bool SetupNonScalingStrokeContext(
    AffineTransform& stroke_transform,
    GraphicsContextStateSaver& state_saver) {
  if (!stroke_transform.IsInvertible())
    return false;

  state_saver.Save();
  state_saver.Context().ConcatCTM(stroke_transform.Inverse());
  return true;
}

static SkPath::FillType FillRuleFromStyle(const PaintInfo& paint_info,
                                          const SVGComputedStyle& svg_style) {
  return WebCoreWindRuleToSkFillType(paint_info.IsRenderingClipPathAsMaskImage()
                                         ? svg_style.ClipRule()
                                         : svg_style.FillRule());
}

void SVGShapePainter::RecordHitTestData(const PaintInfo& paint_info) {
  // Hit test display items are only needed for compositing. This flag is used
  // for for printing and drag images which do not need hit testing.
  if (paint_info.GetGlobalPaintFlags() & kGlobalPaintFlattenCompositingLayers)
    return;

  auto touch_action = layout_svg_shape_.EffectiveWhitelistedTouchAction();
  if (touch_action == TouchAction::kTouchActionAuto)
    return;

  auto rect = LayoutRect(layout_svg_shape_.VisualRectInLocalSVGCoordinates());
  HitTestData::RecordTouchActionRect(paint_info.context, layout_svg_shape_,
                                     TouchActionRect(rect, touch_action));
}

void SVGShapePainter::Paint(const PaintInfo& paint_info) {
  if (paint_info.phase != PaintPhase::kForeground ||
      layout_svg_shape_.StyleRef().Visibility() != EVisibility::kVisible ||
      layout_svg_shape_.IsShapeEmpty())
    return;

  PaintInfo paint_info_before_filtering(paint_info);

  if (SVGModelObjectPainter(layout_svg_shape_)
          .CullRectSkipsPainting(paint_info_before_filtering)) {
    return;
  }
  // Shapes cannot have children so do not call UpdateCullRect.

  SVGTransformContext transform_context(paint_info_before_filtering,
                                        layout_svg_shape_,
                                        layout_svg_shape_.LocalSVGTransform());
  {
    SVGPaintContext paint_context(layout_svg_shape_,
                                  paint_info_before_filtering);
    if (paint_context.ApplyClipMaskAndFilterIfNecessary() &&
        !DrawingRecorder::UseCachedDrawingIfPossible(
            paint_context.GetPaintInfo().context, layout_svg_shape_,
            paint_context.GetPaintInfo().phase)) {
      if (RuntimeEnabledFeatures::PaintTouchActionRectsEnabled())
        RecordHitTestData(paint_info);
      DrawingRecorder recorder(paint_context.GetPaintInfo().context,
                               layout_svg_shape_,
                               paint_context.GetPaintInfo().phase);
      const SVGComputedStyle& svg_style =
          layout_svg_shape_.StyleRef().SvgStyle();

      bool should_anti_alias = svg_style.ShapeRendering() != SR_CRISPEDGES &&
                               svg_style.ShapeRendering() != SR_OPTIMIZESPEED;

      for (int i = 0; i < 3; i++) {
        switch (svg_style.PaintOrderType(i)) {
          case PT_FILL: {
            PaintFlags fill_flags;
            if (!SVGPaintContext::PaintForLayoutObject(
                    paint_context.GetPaintInfo(), layout_svg_shape_.StyleRef(),
                    layout_svg_shape_, kApplyToFillMode, fill_flags))
              break;
            fill_flags.setAntiAlias(should_anti_alias);
            FillShape(
                paint_context.GetPaintInfo().context, fill_flags,
                FillRuleFromStyle(paint_context.GetPaintInfo(), svg_style));
            break;
          }
          case PT_STROKE:
            if (svg_style.HasVisibleStroke()) {
              GraphicsContextStateSaver state_saver(
                  paint_context.GetPaintInfo().context, false);
              AffineTransform non_scaling_transform;
              const AffineTransform* additional_paint_server_transform =
                  nullptr;

              if (layout_svg_shape_.HasNonScalingStroke()) {
                non_scaling_transform =
                    layout_svg_shape_.NonScalingStrokeTransform();
                if (!SetupNonScalingStrokeContext(non_scaling_transform,
                                                  state_saver))
                  return;

                // Non-scaling stroke needs to reset the transform back to the
                // host transform.
                additional_paint_server_transform = &non_scaling_transform;
              }

              PaintFlags stroke_flags;
              if (!SVGPaintContext::PaintForLayoutObject(
                      paint_context.GetPaintInfo(),
                      layout_svg_shape_.StyleRef(), layout_svg_shape_,
                      kApplyToStrokeMode, stroke_flags,
                      additional_paint_server_transform))
                break;
              stroke_flags.setAntiAlias(should_anti_alias);

              StrokeData stroke_data;
              SVGLayoutSupport::ApplyStrokeStyleToStrokeData(
                  stroke_data, layout_svg_shape_.StyleRef(), layout_svg_shape_,
                  layout_svg_shape_.DashScaleFactor());
              stroke_data.SetupPaint(&stroke_flags);

              StrokeShape(paint_context.GetPaintInfo().context, stroke_flags);
            }
            break;
          case PT_MARKERS:
            PaintMarkers(paint_context.GetPaintInfo(),
                         layout_svg_shape_.VisualRectInLocalSVGCoordinates());
            break;
          default:
            NOTREACHED();
            break;
        }
      }
    }
  }

  SVGModelObjectPainter(layout_svg_shape_)
      .PaintOutline(paint_info_before_filtering);
}

class PathWithTemporaryWindingRule {
 public:
  PathWithTemporaryWindingRule(Path& path, SkPath::FillType fill_type)
      : path_(const_cast<SkPath&>(path.GetSkPath())) {
    saved_fill_type_ = path_.getFillType();
    path_.setFillType(fill_type);
  }
  ~PathWithTemporaryWindingRule() { path_.setFillType(saved_fill_type_); }

  const SkPath& GetSkPath() const { return path_; }

 private:
  SkPath& path_;
  SkPath::FillType saved_fill_type_;
};

void SVGShapePainter::FillShape(GraphicsContext& context,
                                const PaintFlags& flags,
                                SkPath::FillType fill_type) {
  switch (layout_svg_shape_.GeometryCodePath()) {
    case kRectGeometryFastPath:
      context.DrawRect(layout_svg_shape_.ObjectBoundingBox(), flags);
      break;
    case kEllipseGeometryFastPath:
      context.DrawOval(layout_svg_shape_.ObjectBoundingBox(), flags);
      break;
    default: {
      PathWithTemporaryWindingRule path_with_winding(
          layout_svg_shape_.GetPath(), fill_type);
      context.DrawPath(path_with_winding.GetSkPath(), flags);
    }
  }
}

void SVGShapePainter::StrokeShape(GraphicsContext& context,
                                  const PaintFlags& flags) {
  if (!layout_svg_shape_.StyleRef().SvgStyle().HasVisibleStroke())
    return;

  switch (layout_svg_shape_.GeometryCodePath()) {
    case kRectGeometryFastPath:
      context.DrawRect(layout_svg_shape_.ObjectBoundingBox(), flags);
      break;
    case kEllipseGeometryFastPath:
      context.DrawOval(layout_svg_shape_.ObjectBoundingBox(), flags);
      break;
    default:
      DCHECK(layout_svg_shape_.HasPath());
      const Path* use_path = &layout_svg_shape_.GetPath();
      if (layout_svg_shape_.HasNonScalingStroke())
        use_path = &layout_svg_shape_.NonScalingStrokePath();
      context.DrawPath(use_path->GetSkPath(), flags);
  }
}

void SVGShapePainter::PaintMarkers(const PaintInfo& paint_info,
                                   const FloatRect& bounding_box) {
  const Vector<MarkerPosition>* marker_positions =
      layout_svg_shape_.MarkerPositions();
  if (!marker_positions || marker_positions->IsEmpty())
    return;

  SVGResources* resources =
      SVGResourcesCache::CachedResourcesForLayoutObject(layout_svg_shape_);
  if (!resources)
    return;

  LayoutSVGResourceMarker* marker_start = resources->MarkerStart();
  LayoutSVGResourceMarker* marker_mid = resources->MarkerMid();
  LayoutSVGResourceMarker* marker_end = resources->MarkerEnd();
  if (!marker_start && !marker_mid && !marker_end)
    return;

  float stroke_width = layout_svg_shape_.StrokeWidth();

  for (const MarkerPosition& marker_position : *marker_positions) {
    if (const LayoutSVGResourceMarker* marker = SVGMarkerData::MarkerForType(
            marker_position.type, marker_start, marker_mid, marker_end)) {
      PaintMarker(paint_info, *marker, marker_position, stroke_width);
    }
  }
}

void SVGShapePainter::PaintMarker(const PaintInfo& paint_info,
                                  const LayoutSVGResourceMarker& marker,
                                  const MarkerPosition& position,
                                  float stroke_width) {
  if (!marker.ShouldPaint())
    return;

  AffineTransform transform = marker.MarkerTransformation(
      position.origin, position.angle, stroke_width);

  cc::PaintCanvas* canvas = paint_info.context.Canvas();

  canvas->save();
  canvas->concat(AffineTransformToSkMatrix(transform));
  if (SVGLayoutSupport::IsOverflowHidden(marker))
    canvas->clipRect(marker.Viewport());

  PaintRecordBuilder builder(nullptr, &paint_info.context);
  PaintInfo marker_paint_info(builder.Context(), paint_info);
  // It's expensive to track the transformed paint cull rect for each
  // marker so just disable culling. The shape paint call will already
  // be culled if it is outside the paint info cull rect.
  marker_paint_info.cull_rect_ = CullRect(LayoutRect::InfiniteIntRect());

  SVGContainerPainter(marker).Paint(marker_paint_info);
  builder.EndRecording(*canvas);

  canvas->restore();
}

}  // namespace blink