/*
 * Copyright (C) 2007 Apple Inc.  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 APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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.
 */

#include "third_party/blink/renderer/platform/drag_image.h"

#include <algorithm>
#include <memory>
#include <utility>

#include "base/memory/ptr_util.h"
#include "base/memory/scoped_refptr.h"
#include "skia/ext/image_operations.h"
#include "third_party/blink/renderer/platform/fonts/font.h"
#include "third_party/blink/renderer/platform/fonts/font_cache.h"
#include "third_party/blink/renderer/platform/fonts/font_description.h"
#include "third_party/blink/renderer/platform/fonts/font_metrics.h"
#include "third_party/blink/renderer/platform/fonts/string_truncator.h"
#include "third_party/blink/renderer/platform/fonts/text_run_paint_info.h"
#include "third_party/blink/renderer/platform/geometry/float_point.h"
#include "third_party/blink/renderer/platform/geometry/float_rect.h"
#include "third_party/blink/renderer/platform/geometry/int_point.h"
#include "third_party/blink/renderer/platform/graphics/bitmap_image.h"
#include "third_party/blink/renderer/platform/graphics/canvas_resource_provider.h"
#include "third_party/blink/renderer/platform/graphics/color.h"
#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h"
#include "third_party/blink/renderer/platform/graphics/static_bitmap_image.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
#include "third_party/blink/renderer/platform/text/bidi_text_run.h"
#include "third_party/blink/renderer/platform/text/text_run.h"
#include "third_party/blink/renderer/platform/transforms/affine_transform.h"
#include "third_party/blink/renderer/platform/weborigin/kurl.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkColorSpaceXformCanvas.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkMatrix.h"
#include "third_party/skia/include/core/SkSurface.h"

namespace blink {

namespace {

const float kDragLabelBorderX = 4;
// Keep border_y in synch with DragController::LinkDragBorderInset.
const float kDragLabelBorderY = 2;
const float kLabelBorderYOffset = 2;

const float kMaxDragLabelWidth = 300;
const float kMaxDragLabelStringWidth =
    (kMaxDragLabelWidth - 2 * kDragLabelBorderX);

const float kDragLinkLabelFontSize = 11;
const float kDragLinkUrlFontSize = 10;

}  // anonymous namespace

PaintImage DragImage::ResizeAndOrientImage(
    const PaintImage& image,
    ImageOrientation orientation,
    FloatSize image_scale,
    float opacity,
    InterpolationQuality interpolation_quality) {
  IntSize size(image.width(), image.height());
  size.Scale(image_scale.Width(), image_scale.Height());
  AffineTransform transform;
  if (orientation != kDefaultImageOrientation) {
    if (orientation.UsesWidthAsHeight())
      size = size.TransposedSize();
    transform *= orientation.TransformFromDefault(FloatSize(size));
  }
  transform.ScaleNonUniform(image_scale.Width(), image_scale.Height());

  if (size.IsEmpty())
    return PaintImage();

  if (transform.IsIdentity() && opacity == 1) {
    // Nothing to adjust, just use the original.
    DCHECK_EQ(image.width(), size.Width());
    DCHECK_EQ(image.height(), size.Height());
    return image;
  }

  sk_sp<SkSurface> surface =
      SkSurface::MakeRasterN32Premul(size.Width(), size.Height());
  if (!surface)
    return PaintImage();

  SkPaint paint;
  DCHECK_GE(opacity, 0);
  DCHECK_LE(opacity, 1);
  paint.setAlpha(opacity * 255);
  paint.setFilterQuality(interpolation_quality == kInterpolationNone
                             ? kNone_SkFilterQuality
                             : kHigh_SkFilterQuality);

  SkCanvas* canvas = surface->getCanvas();
  std::unique_ptr<SkCanvas> color_transform_canvas;
  color_transform_canvas =
      SkCreateColorSpaceXformCanvas(canvas, SkColorSpace::MakeSRGB());
  canvas = color_transform_canvas.get();
  canvas->concat(AffineTransformToSkMatrix(transform));
  canvas->drawImage(image.GetSkImage(), 0, 0, &paint);

  return PaintImageBuilder::WithProperties(std::move(image))
      .set_image(surface->makeImageSnapshot(), PaintImage::GetNextContentId())
      .TakePaintImage();
}

FloatSize DragImage::ClampedImageScale(const IntSize& image_size,
                                       const IntSize& size,
                                       const IntSize& max_size) {
  // Non-uniform scaling for size mapping.
  FloatSize image_scale(
      static_cast<float>(size.Width()) / image_size.Width(),
      static_cast<float>(size.Height()) / image_size.Height());

  // Uniform scaling for clamping.
  const float clamp_scale_x =
      size.Width() > max_size.Width()
          ? static_cast<float>(max_size.Width()) / size.Width()
          : 1;
  const float clamp_scale_y =
      size.Height() > max_size.Height()
          ? static_cast<float>(max_size.Height()) / size.Height()
          : 1;
  image_scale.Scale(std::min(clamp_scale_x, clamp_scale_y));

  return image_scale;
}

std::unique_ptr<DragImage> DragImage::Create(
    Image* image,
    RespectImageOrientationEnum should_respect_image_orientation,
    float device_scale_factor,
    InterpolationQuality interpolation_quality,
    float opacity,
    FloatSize image_scale) {
  if (!image)
    return nullptr;

  PaintImage paint_image = image->PaintImageForCurrentFrame();
  if (!paint_image)
    return nullptr;

  ImageOrientation orientation;
  if (should_respect_image_orientation == kRespectImageOrientation &&
      image->IsBitmapImage())
    orientation = ToBitmapImage(image)->CurrentFrameOrientation();

  SkBitmap bm;
  paint_image = ResizeAndOrientImage(paint_image, orientation, image_scale,
                                     opacity, interpolation_quality);
  if (!paint_image || !paint_image.GetSkImage()->asLegacyBitmap(&bm))
    return nullptr;

  return base::WrapUnique(
      new DragImage(bm, device_scale_factor, interpolation_quality));
}

static Font DeriveDragLabelFont(int size,
                                FontSelectionValue font_weight,
                                const FontDescription& system_font) {
  FontDescription description = system_font;
  description.SetWeight(font_weight);
  description.SetSpecifiedSize(size);
  description.SetComputedSize(size);
  Font result(description);
  result.Update(nullptr);
  return result;
}

std::unique_ptr<DragImage> DragImage::Create(const KURL& url,
                                             const String& in_label,
                                             const FontDescription& system_font,
                                             float device_scale_factor) {
  const Font label_font = DeriveDragLabelFont(kDragLinkLabelFontSize,
                                              BoldWeightValue(), system_font);
  const SimpleFontData* label_font_data = label_font.PrimaryFont();
  DCHECK(label_font_data);
  const Font url_font = DeriveDragLabelFont(kDragLinkUrlFontSize,
                                            NormalWeightValue(), system_font);
  const SimpleFontData* url_font_data = url_font.PrimaryFont();
  DCHECK(url_font_data);

  if (!label_font_data || !url_font_data)
    return nullptr;

  FontCachePurgePreventer font_cache_purge_preventer;

  bool draw_url_string = true;
  bool clip_url_string = false;
  bool clip_label_string = false;
  float max_drag_label_string_width_dip =
      kMaxDragLabelStringWidth / device_scale_factor;

  String url_string = url.GetString();
  String label = in_label.StripWhiteSpace();
  if (label.IsEmpty()) {
    draw_url_string = false;
    label = url_string;
  }

  // First step is drawing the link drag image width.
  TextRun label_run(label.Impl());
  TextRun url_run(url_string.Impl());
  IntSize label_size(label_font.Width(label_run),
                     label_font_data->GetFontMetrics().Ascent() +
                         label_font_data->GetFontMetrics().Descent());

  if (label_size.Width() > max_drag_label_string_width_dip) {
    label_size.SetWidth(max_drag_label_string_width_dip);
    clip_label_string = true;
  }

  IntSize url_string_size;
  IntSize image_size(label_size.Width() + kDragLabelBorderX * 2,
                     label_size.Height() + kDragLabelBorderY * 2);

  if (draw_url_string) {
    url_string_size.SetWidth(url_font.Width(url_run));
    url_string_size.SetHeight(url_font_data->GetFontMetrics().Ascent() +
                              url_font_data->GetFontMetrics().Descent());
    image_size.SetHeight(image_size.Height() + url_string_size.Height());
    if (url_string_size.Width() > max_drag_label_string_width_dip) {
      image_size.SetWidth(max_drag_label_string_width_dip);
      clip_url_string = true;
    } else {
      image_size.SetWidth(
          std::max(label_size.Width(), url_string_size.Width()) +
          kDragLabelBorderX * 2);
    }
  }

  // We now know how big the image needs to be, so we create and
  // fill the background
  IntSize scaled_image_size = image_size;
  scaled_image_size.Scale(device_scale_factor);
  std::unique_ptr<CanvasResourceProvider> resource_provider(
      CanvasResourceProvider::Create(
          scaled_image_size, CanvasResourceProvider::kSoftwareResourceUsage,
          nullptr,  // context_provider_wrapper
          0,        // msaa_sample_count
          CanvasColorParams(), CanvasResourceProvider::kDefaultPresentationMode,
          nullptr));  // canvas_resource_dispatcher
  if (!resource_provider)
    return nullptr;

  resource_provider->Canvas()->scale(device_scale_factor, device_scale_factor);

  const float kDragLabelRadius = 5;

  IntRect rect(IntPoint(), image_size);
  PaintFlags background_paint;
  background_paint.setColor(SkColorSetRGB(140, 140, 140));
  background_paint.setAntiAlias(true);
  SkRRect rrect;
  rrect.setRectXY(SkRect::MakeWH(image_size.Width(), image_size.Height()),
                  kDragLabelRadius, kDragLabelRadius);
  resource_provider->Canvas()->drawRRect(rrect, background_paint);

  // Draw the text
  PaintFlags text_paint;
  if (draw_url_string) {
    if (clip_url_string)
      url_string = StringTruncator::CenterTruncate(
          url_string, image_size.Width() - (kDragLabelBorderX * 2.0f),
          url_font);
    FloatPoint text_pos(
        kDragLabelBorderX,
        image_size.Height() -
            (kLabelBorderYOffset + url_font_data->GetFontMetrics().Descent()));
    TextRun text_run(url_string);
    url_font.DrawText(resource_provider->Canvas(), TextRunPaintInfo(text_run),
                      text_pos, device_scale_factor, text_paint);
  }

  if (clip_label_string)
    label = StringTruncator::RightTruncate(
        label, image_size.Width() - (kDragLabelBorderX * 2.0f), label_font);

  bool has_strong_directionality;
  TextRun text_run =
      TextRunWithDirectionality(label, &has_strong_directionality);
  IntPoint text_pos(
      kDragLabelBorderX,
      kDragLabelBorderY + label_font.GetFontDescription().ComputedPixelSize());
  if (has_strong_directionality &&
      text_run.Direction() == TextDirection::kRtl) {
    float text_width = label_font.Width(text_run);
    int available_width = image_size.Width() - kDragLabelBorderX * 2;
    text_pos.SetX(available_width - ceilf(text_width));
  }
  label_font.DrawBidiText(resource_provider->Canvas(),
                          TextRunPaintInfo(text_run), FloatPoint(text_pos),
                          Font::kDoNotPaintIfFontNotReady, device_scale_factor,
                          text_paint);

  scoped_refptr<StaticBitmapImage> image = resource_provider->Snapshot();
  return DragImage::Create(image.get(), kDoNotRespectImageOrientation,
                           device_scale_factor);
}

DragImage::DragImage(const SkBitmap& bitmap,
                     float resolution_scale,
                     InterpolationQuality interpolation_quality)
    : bitmap_(bitmap),
      resolution_scale_(resolution_scale),
      interpolation_quality_(interpolation_quality) {}

DragImage::~DragImage() = default;

void DragImage::Scale(float scale_x, float scale_y) {
  skia::ImageOperations::ResizeMethod resize_method =
      interpolation_quality_ == kInterpolationNone
          ? skia::ImageOperations::RESIZE_BOX
          : skia::ImageOperations::RESIZE_LANCZOS3;
  int image_width = scale_x * bitmap_.width();
  int image_height = scale_y * bitmap_.height();
  bitmap_ = skia::ImageOperations::Resize(bitmap_, resize_method, image_width,
                                          image_height);
}

}  // namespace blink