// Copyright 2019 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 "ui/gfx/mac/cocoa_scrollbar_painter.h"

#include "ui/gfx/canvas.h"
#include "ui/gfx/skia_util.h"

namespace gfx {

using Params = CocoaScrollbarPainter::Params;
using Orientation = CocoaScrollbarPainter::Orientation;

namespace {

// The width of the scroller track border.
constexpr int kTrackBorderWidth = 1;

// The amount the thumb is inset from the ends and the inside edge of track
// border.
constexpr int kThumbInset = 3;
constexpr int kThumbInsetOverlay = 2;

// The minimum sizes for the thumb. We will not inset the thumb if it will
// be smaller than this size.
constexpr int kThumbMinGirth = 6;
constexpr int kThumbMinLength = 18;

// Scrollbar thumb colors.
constexpr SkColor kThumbColorDefault = SkColorSetARGB(0x3A, 0, 0, 0);
constexpr SkColor kThumbColorHover = SkColorSetARGB(0x80, 0, 0, 0);
constexpr SkColor kThumbColorDarkMode = SkColorSetRGB(0x6B, 0x6B, 0x6B);
constexpr SkColor kThumbColorDarkModeHover = SkColorSetRGB(0x93, 0x93, 0x93);
constexpr SkColor kThumbColorOverlay = SkColorSetARGB(0x80, 0, 0, 0);
constexpr SkColor kThumbColorOverlayDarkMode =
    SkColorSetARGB(0x80, 0xFF, 0xFF, 0xFF);

// Non-overlay scroller track colors are not transparent. On Safari, they are,
// but on all other macOS applications they are not.
constexpr SkColor kTrackGradientColors[] = {
    SkColorSetRGB(0xFA, 0xFA, 0xFA),
    SkColorSetRGB(0xFA, 0xFA, 0xFA),
};
constexpr SkColor kTrackInnerBorderColor = SkColorSetRGB(0xE8, 0xE8, 0xE8);
constexpr SkColor kTrackOuterBorderColor = SkColorSetRGB(0xED, 0xED, 0xED);

// Non-overlay dark mode scroller track colors.
constexpr SkColor kTrackGradientColorsDarkMode[] = {
    SkColorSetRGB(0x2D, 0x2D, 0x2D),
    SkColorSetRGB(0x2B, 0x2B, 0x2B),
};
constexpr SkColor kTrackInnerBorderColorDarkMode =
    SkColorSetRGB(0x3D, 0x3D, 0x3D);
constexpr SkColor kTrackOuterBorderColorDarkMode =
    SkColorSetRGB(0x51, 0x51, 0x51);

// Overlay scroller track colors are transparent.
constexpr SkColor kTrackGradientColorsOverlay[] = {
    SkColorSetARGB(0xC6, 0xF8, 0xF8, 0xF8),
    SkColorSetARGB(0xC2, 0xF8, 0xF8, 0xF8),
    SkColorSetARGB(0xC2, 0xF8, 0xF8, 0xF8),
    SkColorSetARGB(0xC2, 0xF8, 0xF8, 0xF8),
};
constexpr SkColor kTrackInnerBorderColorOverlay =
    SkColorSetARGB(0xF9, 0xDF, 0xDF, 0xDF);
constexpr SkColor kTrackOuterBorderColorOverlay =
    SkColorSetARGB(0xC6, 0xE8, 0xE8, 0xE8);

// Dark mode overlay scroller track colors.
constexpr SkColor kTrackGradientColorsOverlayDarkMode[] = {
    SkColorSetARGB(0x28, 0xD8, 0xD8, 0xD8),
    SkColorSetARGB(0x26, 0xCC, 0xCC, 0xCC),
    SkColorSetARGB(0x26, 0xCC, 0xCC, 0xCC),
    SkColorSetARGB(0x26, 0xCC, 0xCC, 0xCC),
};
constexpr SkColor kTrackInnerBorderColorOverlayDarkMode =
    SkColorSetARGB(0x33, 0xE5, 0xE5, 0xE5);
constexpr SkColor kTrackOuterBorderColorOverlayDarkMode =
    SkColorSetARGB(0x28, 0xD8, 0xD8, 0xD8);

void ConstrainInsets(int old_width, int min_width, int* left, int* right) {
  int requested_total_inset = *left + *right;
  if (requested_total_inset == 0)
    return;
  int max_total_inset = old_width - min_width;
  if (requested_total_inset < max_total_inset)
    return;
  if (max_total_inset < 0) {
    *left = *right = 0;
    return;
  }
  // Multiply the right/bottom inset by the ratio by which we need to shrink the
  // total inset. This has the effect of rounding down the right/bottom inset,
  // if the two sides are to be affected unevenly.
  *right *= max_total_inset * 1.f / requested_total_inset;
  *left = max_total_inset - *right;
}

void ConstrainedInset(gfx::Rect* rect,
                      int min_width,
                      int min_height,
                      int inset_left,
                      int inset_top,
                      int inset_right,
                      int inset_bottom) {
  ConstrainInsets(rect->width(), min_width, &inset_left, &inset_right);
  ConstrainInsets(rect->height(), min_height, &inset_top, &inset_bottom);
  rect->Inset(inset_left, inset_top, inset_right, inset_bottom);
}

void PaintTrackGradient(gfx::Canvas* canvas,
                        const gfx::Rect& rect,
                        const Params& params,
                        bool is_corner) {
  // Select colors.
  const SkColor* gradient_colors = nullptr;
  size_t gradient_stops = 0;
  if (params.overlay) {
    if (params.dark_mode) {
      gradient_colors = kTrackGradientColorsOverlayDarkMode;
      gradient_stops = base::size(kTrackGradientColorsOverlayDarkMode);
    } else {
      gradient_colors = kTrackGradientColorsOverlay;
      gradient_stops = base::size(kTrackGradientColorsOverlay);
    }
  } else {
    if (params.dark_mode) {
      gradient_colors = kTrackGradientColorsDarkMode;
      gradient_stops = base::size(kTrackGradientColorsDarkMode);
    } else {
      gradient_colors = kTrackGradientColors;
      gradient_stops = base::size(kTrackGradientColors);
    }
  }

  // Set the gradient direction.
  const SkPoint gradient_bounds_vertical[] = {
      gfx::PointToSkPoint(rect.origin()),
      gfx::PointToSkPoint(rect.bottom_left()),
  };
  const SkPoint gradient_bounds_horizontal[] = {
      gfx::PointToSkPoint(rect.origin()),
      gfx::PointToSkPoint(rect.top_right()),
  };
  const SkPoint gradient_bounds_corner_right[] = {
      gfx::PointToSkPoint(rect.origin()),
      gfx::PointToSkPoint(rect.bottom_right()),
  };
  const SkPoint gradient_bounds_corner_left[] = {
      gfx::PointToSkPoint(rect.top_right()),
      gfx::PointToSkPoint(rect.bottom_left()),
  };
  const SkPoint* gradient_bounds = nullptr;
  if (is_corner) {
    if (params.orientation == Orientation::kVerticalOnRight)
      gradient_bounds = gradient_bounds_corner_right;
    else
      gradient_bounds = gradient_bounds_corner_left;
  } else {
    if (params.orientation == Orientation::kHorizontal)
      gradient_bounds = gradient_bounds_horizontal;
    else
      gradient_bounds = gradient_bounds_vertical;
  }

  // And draw.
  cc::PaintFlags gradient;
  gradient.setShader(cc::PaintShader::MakeLinearGradient(
      gradient_bounds, gradient_colors, nullptr, gradient_stops,
      SkTileMode::kClamp));
  canvas->DrawRect(rect, gradient);
}

void PaintTrackInnerBorder(gfx::Canvas* canvas,
                           const gfx::Rect& rect,
                           const Params& params,
                           bool is_corner) {
  // Select the color.
  SkColor inner_border_color = 0;
  if (params.overlay) {
    if (params.dark_mode)
      inner_border_color = kTrackInnerBorderColorOverlayDarkMode;
    else
      inner_border_color = kTrackInnerBorderColorOverlay;
  } else {
    if (params.dark_mode)
      inner_border_color = kTrackInnerBorderColorDarkMode;
    else
      inner_border_color = kTrackInnerBorderColor;
  }

  // Compute the rect for the border.
  gfx::Rect inner_border(rect);
  if (params.orientation == Orientation::kVerticalOnLeft)
    inner_border.set_x(rect.right() - kTrackBorderWidth);
  if (is_corner || params.orientation == Orientation::kHorizontal)
    inner_border.set_height(kTrackBorderWidth);
  if (is_corner || params.orientation != Orientation::kHorizontal)
    inner_border.set_width(kTrackBorderWidth);

  // And draw.
  cc::PaintFlags flags;
  flags.setColor(inner_border_color);
  canvas->DrawRect(inner_border, flags);
}

void PaintTrackOuterBorder(gfx::Canvas* canvas,
                           const gfx::Rect& rect,
                           const Params& params,
                           bool is_corner) {
  // Select the color.
  SkColor outer_border_color = 0;
  if (params.overlay) {
    if (params.dark_mode)
      outer_border_color = kTrackOuterBorderColorOverlayDarkMode;
    else
      outer_border_color = kTrackOuterBorderColorOverlay;
  } else {
    if (params.dark_mode)
      outer_border_color = kTrackOuterBorderColorDarkMode;
    else
      outer_border_color = kTrackOuterBorderColor;
  }
  cc::PaintFlags flags;
  flags.setColor(outer_border_color);

  // Draw the horizontal outer border.
  if (is_corner || params.orientation == Orientation::kHorizontal) {
    gfx::Rect outer_border(rect);
    outer_border.set_height(kTrackBorderWidth);
    outer_border.set_y(rect.bottom() - kTrackBorderWidth);
    canvas->DrawRect(outer_border, flags);
  }

  // Draw the vertial outer border.
  if (is_corner || params.orientation != Orientation::kHorizontal) {
    gfx::Rect outer_border(rect);
    outer_border.set_width(kTrackBorderWidth);
    if (params.orientation == Orientation::kVerticalOnRight)
      outer_border.set_x(rect.right() - kTrackBorderWidth);
    canvas->DrawRect(outer_border, flags);
  }
}

}  // namespace

// static
void CocoaScrollbarPainter::PaintTrack(cc::PaintCanvas* cc_canvas,
                                       const SkIRect& sk_track_rect,
                                       const Params& params) {
  gfx::Canvas canvas(cc_canvas, 1.f);
  const gfx::Rect track_rect(SkIRectToRect(sk_track_rect));
  constexpr bool is_corner = false;
  PaintTrackGradient(&canvas, track_rect, params, is_corner);
  PaintTrackInnerBorder(&canvas, track_rect, params, is_corner);
  PaintTrackOuterBorder(&canvas, track_rect, params, is_corner);
}

// static
void CocoaScrollbarPainter::PaintCorner(cc::PaintCanvas* cc_canvas,
                                        const SkIRect& sk_corner_rect,
                                        const Params& params) {
  // Overlay scrollbars don't have a corner.
  if (params.overlay)
    return;
  gfx::Canvas canvas(cc_canvas, 1.f);
  const gfx::Rect corner_rect(SkIRectToRect(sk_corner_rect));
  constexpr bool is_corner = true;
  PaintTrackGradient(&canvas, corner_rect, params, is_corner);
  PaintTrackInnerBorder(&canvas, corner_rect, params, is_corner);
  PaintTrackOuterBorder(&canvas, corner_rect, params, is_corner);
}

// static
void CocoaScrollbarPainter::PaintThumb(cc::PaintCanvas* cc_canvas,
                                       const SkIRect& sk_bounds,
                                       const Params& params) {
  gfx::Canvas canvas(cc_canvas, 1.f);

  // Select the color.
  SkColor thumb_color = 0;
  if (params.overlay) {
    if (params.dark_mode)
      thumb_color = kThumbColorOverlayDarkMode;
    else
      thumb_color = kThumbColorOverlay;
  } else {
    if (params.dark_mode) {
      if (params.hovered)
        thumb_color = kThumbColorDarkModeHover;
      else
        thumb_color = kThumbColorDarkMode;
    } else {
      if (params.hovered)
        thumb_color = kThumbColorHover;
      else
        thumb_color = kThumbColorDefault;
    }
  }

  // Compute the bounds for the rounded rect for the thumb from the bounds of
  // the thumb.
  gfx::Rect bounds(SkIRectToRect(sk_bounds));
  {
    // Shrink the thumb evenly in length and girth to fit within the track.
    const int thumb_inset = params.overlay ? kThumbInsetOverlay : kThumbInset;
    int inset_left = thumb_inset;
    int inset_top = thumb_inset;
    int inset_right = thumb_inset;
    int inset_bottom = thumb_inset;

    // Also shrink the thumb in girth to not touch the border.
    if (params.orientation == Orientation::kHorizontal) {
      inset_top += kTrackBorderWidth;
      ConstrainedInset(&bounds, kThumbMinLength, kThumbMinGirth, inset_left,
                       inset_top, inset_right, inset_bottom);
    } else {
      inset_left += kTrackBorderWidth;
      ConstrainedInset(&bounds, kThumbMinGirth, kThumbMinLength, inset_left,
                       inset_top, inset_right, inset_bottom);
    }
  }

  // Draw.
  cc::PaintFlags flags;
  flags.setAntiAlias(true);
  flags.setStyle(cc::PaintFlags::kFill_Style);
  flags.setColor(thumb_color);
  const SkScalar radius = std::min(bounds.width(), bounds.height());
  canvas.DrawRoundRect(bounds, radius, flags);
}

}  // namespace gfx