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

#include "chrome/browser/ui/toasts/toast_view.h"

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

#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "chrome/app/vector_icons/vector_icons.h"
#include "chrome/browser/ui/browser_element_identifiers.h"
#include "chrome/browser/ui/views/chrome_layout_provider.h"
#include "chrome/browser/ui/views/chrome_typography.h"
#include "chrome/grit/generated_resources.h"
#include "components/strings/grit/components_strings.h"
#include "components/vector_icons/vector_icons.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/models/menu_model.h"
#include "ui/base/mojom/menu_source_type.mojom.h"
#include "ui/compositor/layer.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/animation/animation_builder.h"
#include "ui/views/border.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/controls/button/image_button_factory.h"
#include "ui/views/controls/highlight_path_generator.h"
#include "ui/views/controls/menu/menu_item_view.h"
#include "ui/views/controls/menu/menu_model_adapter.h"
#include "ui/views/controls/menu/menu_runner.h"
#include "ui/views/layout/flex_layout.h"
#include "ui/views/layout/flex_layout_types.h"
#include "ui/views/layout/layout_provider.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/widget/widget.h"
#include "ui/views/window/dialog_client_view.h"
#include "ui/views/window/dialog_delegate.h"

namespace {
constexpr int kAnimationEntryDuration = 300;
constexpr int kAnimationExitDuration = 150;
constexpr int kAnimationHeightOffset = 50;
constexpr float kAnimationHeightScale = 0.5;

gfx::Transform GetScaleTransformation(gfx::Rect bounds) {
  gfx::Transform transform;
  transform.Translate(0,
                      bounds.CenterPoint().y() * (1 - kAnimationHeightScale));
  transform.Scale(1, kAnimationHeightScale);
  return transform;
}

bool IsCompatibleImageSize(const ui::ImageModel* image) {
  const auto intended_size = toasts::ToastView::GetIconSize();
  const auto image_size = image->Size();
  return image_size.width() == intended_size &&
         image_size.height() == intended_size;
}

gfx::Insets GetLeftMargin(const int left_margin) {
  return gfx::Insets::TLBR(0, left_margin, 0, 0);
}

// A simple `MenuModelAdapter` that runs `on_executed_command` whenever the
// command corresponding to a menu item is executed.
class ToastMenuModelAdapter : public views::MenuModelAdapter {
 public:
  ToastMenuModelAdapter(ui::MenuModel* menu_model,
                        base::RepeatingClosure on_menu_closed,
                        base::RepeatingClosure on_executed_command)
      : views::MenuModelAdapter(menu_model, std::move(on_menu_closed)),
        on_executed_command_(std::move(on_executed_command)) {}

  ~ToastMenuModelAdapter() override = default;

 private:
  // views::MenuModelAdapter:
  void ExecuteCommand(int id) override {
    views::MenuModelAdapter::ExecuteCommand(id);
    on_executed_command_.Run();
  }

  void ExecuteCommand(int id, int mouse_event_flags) override {
    views::MenuModelAdapter::ExecuteCommand(id, mouse_event_flags);
    on_executed_command_.Run();
  }

  base::RepeatingClosure on_executed_command_;
};

}  // namespace

namespace toasts {
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(ToastView, kToastViewId);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(ToastView, kToastActionButton);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(ToastView, kToastCloseButton);
DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(ToastView, kToastMenuButton);

ToastView::ToastView(
    views::View* anchor_view,
    const std::u16string& toast_text,
    const gfx::VectorIcon& icon,
    const ui::ImageModel* image_override,
    bool render_toast_over_web_contents,
    base::RepeatingCallback<void(ToastCloseReason)> toast_close_callback)
    : BubbleDialogDelegateView(anchor_view, views::BubbleBorder::NONE),
      AnimationDelegateViews(this),
      toast_text_(toast_text),
      icon_(icon),
      image_override_(image_override),
      render_toast_over_web_contents_(render_toast_over_web_contents),
      toast_close_callback_(std::move(toast_close_callback)) {
  SetBackgroundColor(ui::kColorToastBackgroundProminent);
  SetShowCloseButton(false);
  DialogDelegate::SetButtons(static_cast<int>(ui::mojom::DialogButton::kNone));
  set_corner_radius(ChromeLayoutProvider::Get()->GetDistanceMetric(
      DISTANCE_TOAST_BUBBLE_HEIGHT));
  SetProperty(views::kElementIdentifierKey, kToastElementId);
  set_close_on_deactivate(false);
  SetProperty(views::kElementIdentifierKey, kToastViewId);
  SetAccessibleWindowRole(ax::mojom::Role::kAlert);
  SetAccessibleTitle(toast_text_);
}

ToastView::~ToastView() = default;

void ToastView::AddActionButton(const std::u16string& action_button_text,
                                base::RepeatingClosure action_button_callback) {
  CHECK(!has_action_button_);
  has_action_button_ = true;
  action_button_text_ = action_button_text;
  action_button_callback_ = std::move(action_button_callback);
}

void ToastView::AddCloseButton(base::RepeatingClosure close_callback) {
  CHECK(!has_close_button_);
  has_close_button_ = true;
  close_button_callback_ = std::move(close_callback);
}

void ToastView::AddMenu(std::unique_ptr<ui::MenuModel> model) {
  CHECK(!menu_model_);
  menu_model_ = std::move(model);
  menu_model_adapter_ = std::make_unique<ToastMenuModelAdapter>(
      menu_model_.get(),
      /*on_menu_closed=*/
      base::BindRepeating(&ToastView::OnMenuClosed, base::Unretained(this)),
      /*on_executed_command=*/
      base::BindRepeating(&ToastView::Close, base::Unretained(this),
                          ToastCloseReason::kMenuItemClick));
}

int ToastView::GetIconSize() {
  const ChromeLayoutProvider* lp = ChromeLayoutProvider::Get();
  return lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_ICON_SIZE);
}

void ToastView::Init() {
  ChromeLayoutProvider* lp = ChromeLayoutProvider::Get();

  // FlexLayout lets the toast compress itself in narrow browser windows.
  SetLayoutManager(std::make_unique<views::FlexLayout>())
      ->SetOrientation(views::LayoutOrientation::kHorizontal);

  icon_view_ = AddChildView(std::make_unique<views::ImageView>());
  icon_view_->SetProperty(
      views::kMarginsKey,
      gfx::Insets::VH(0, lp->GetDistanceMetric(
                             DISTANCE_TOAST_BUBBLE_LEADING_ICON_SIDE_MARGINS)));

  label_ = AddChildView(
      std::make_unique<views::Label>(toast_text_, CONTEXT_TOAST_BODY_TEXT));
  label_->SetEnabledColor(ui::kColorToastForeground);
  label_->SetMultiLine(false);
  label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
  label_->SetAllowCharacterBreak(false);
  label_->SetAutoColorReadabilityEnabled(false);
  label_->SetLineHeight(
      lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_HEIGHT_CONTENT));
  label_->SetProperty(views::kMarginsKey,
                      GetLeftMargin(lp->GetDistanceMetric(
                          DISTANCE_TOAST_BUBBLE_BETWEEN_CHILD_SPACING)));
  label_->SetProperty(
      views::kFlexBehaviorKey,
      views::FlexSpecification(views::LayoutOrientation::kHorizontal,
                               views::MinimumFlexSizeRule::kScaleToZero));

  int max_child_height =
      lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_HEIGHT_CONTENT);

  if (has_action_button_) {
    action_button_ = AddChildView(std::make_unique<views::MdTextButton>(
        action_button_callback_.Then(
            base::BindRepeating(&ToastView::Close, base::Unretained(this),
                                ToastCloseReason::kActionButton)),
        action_button_text_));
    action_button_->SetEnabledTextColors(ui::kColorToastButton);
    action_button_->SetBgColorIdOverride(ui::kColorToastBackgroundProminent);
    action_button_->SetStrokeColorIdOverride(ui::kColorToastButton);
    action_button_->SetPreferredSize(gfx::Size(
        action_button_->GetPreferredSize().width(),
        lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_HEIGHT_ACTION_BUTTON)));
    action_button_->SetStyle(ui::ButtonStyle::kProminent);
    action_button_->GetViewAccessibility().SetRole(ax::mojom::Role::kAlert);
    action_button_->SetProperty(views::kElementIdentifierKey,
                                kToastActionButton);
    action_button_->SetAppearDisabledInInactiveWidget(false);
    action_button_->SetProperty(
        views::kMarginsKey,
        GetLeftMargin(lp->GetDistanceMetric(
            DISTANCE_TOAST_BUBBLE_BETWEEN_LABEL_ACTION_BUTTON_SPACING)));
    SetInitiallyFocusedView(action_button_);
    max_child_height = std::max(
        max_child_height,
        lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_HEIGHT_ACTION_BUTTON));
  }

  if (has_close_button_) {
    close_button_ = AddChildView(views::CreateVectorImageButtonWithNativeTheme(
        close_button_callback_.Then(
            base::BindRepeating(&ToastView::Close, base::Unretained(this),
                                ToastCloseReason::kCloseButton)),
        vector_icons::kCloseChromeRefreshIcon,
        lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_ICON_SIZE),
        ui::kColorToastForeground));
    // Override the image button's border with the appropriate icon border size.
    const gfx::Insets insets =
        lp->GetInsetsMetric(views::InsetsMetric::INSETS_VECTOR_IMAGE_BUTTON);
    close_button_->SetBorder(views::CreateEmptyBorder(insets));
    views::InstallCircleHighlightPathGenerator(close_button_);
    close_button_->SetAccessibleName(l10n_util::GetStringUTF16(IDS_CLOSE));
    close_button_->SetProperty(views::kElementIdentifierKey, kToastCloseButton);
    close_button_->SetProperty(
        views::kMarginsKey, GetLeftMargin(lp->GetDistanceMetric(
                                DISTANCE_TOAST_BUBBLE_BETWEEN_CHILD_SPACING)));
    close_button_->SetTooltipText(
        l10n_util::GetStringUTF16(IDS_TOAST_CLOSE_TOOLTIP));
    if (!HasConfiguredInitiallyFocusedView()) {
      SetInitiallyFocusedView(close_button_);
    }
    max_child_height =
        std::max(max_child_height,
                 lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_ICON_SIZE) +
                     insets.height());
  }

  if (menu_model_) {
    menu_button_ = AddChildView(views::CreateVectorImageButtonWithNativeTheme(
        base::RepeatingClosure(), kBrowserToolsChromeRefreshIcon,
        /*dip_size=*/
        lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_MENU_ICON_SIZE),
        ui::kColorToastForeground));
    views::InstallCircleHighlightPathGenerator(menu_button_);
    menu_button_->SetProperty(views::kElementIdentifierKey, kToastMenuButton);
    menu_button_->SetButtonController(
        std::make_unique<views::MenuButtonController>(
            menu_button_,
            base::BindRepeating(&ToastView::OnMenuButtonClicked,
                                base::Unretained(this)),
            std::make_unique<views::Button::DefaultButtonControllerDelegate>(
                menu_button_)));
    menu_button_->SetAccessibleName(
        l10n_util::GetStringUTF16(IDS_TOAST_MENU_BUTTON_NAME));
    const gfx::Insets insets = menu_button_->GetInsets();
    const int left_margin =
        lp->GetDistanceMetric(
            DISTANCE_TOAST_BUBBLE_BETWEEN_LABEL_MENU_BUTTON_SPACING) -
        insets.left();
    menu_button_->SetProperty(views::kMarginsKey, GetLeftMargin(left_margin));
    if (!HasConfiguredInitiallyFocusedView()) {
      SetInitiallyFocusedView(menu_button_);
    }
    max_child_height =
        std::max(max_child_height,
                 lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_MENU_ICON_SIZE) +
                     insets.height());
  }

  // Height of the toast is set implicitly by adding margins depending on the
  // height of the tallest child. We cannot simply iterate over all children
  // here because the `ImageModel` for `ImageButton`s is only set once the theme
  // is available.
  const int total_vertical_margins =
      lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_HEIGHT) - max_child_height;
  const int top_margin = total_vertical_margins / 2;
  const int right_margin = [&]() {
    if (menu_button_) {
      return lp->GetDistanceMetric(
          DISTANCE_TOAST_BUBBLE_MARGIN_RIGHT_CLOSE_BUTTON);
    } else if (close_button_) {
      return lp->GetDistanceMetric(
          DISTANCE_TOAST_BUBBLE_MARGIN_RIGHT_CLOSE_BUTTON);
    } else if (action_button_) {
      return lp->GetDistanceMetric(
          DISTANCE_TOAST_BUBBLE_MARGIN_RIGHT_ACTION_BUTTON);
    }
    return lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_MARGIN_RIGHT_LABEL);
  }();
  set_margins(gfx::Insets::TLBR(
      top_margin, lp->GetDistanceMetric(DISTANCE_TOAST_BUBBLE_MARGIN_LEFT),
      total_vertical_margins - top_margin, right_margin));

  if (has_action_button_ || has_close_button_ || menu_model_) {
    SetFocusTraversesOut(true);
  } else {
    set_focus_traversable_from_anchor_view(false);
    SetCanActivate(false);
  }
}

void ToastView::AnimationProgressed(const gfx::Animation* animation) {
  const double value = gfx::Tween::CalculateValue(
      height_animation_tween_, height_animation_.GetCurrentValue());
  const gfx::Rect current_bounds = gfx::Tween::RectValueBetween(
      value, starting_widget_bounds_, target_widget_bounds_);
  GetWidget()->SetBounds(current_bounds);
}

void ToastView::AnimateIn() {
  if (!gfx::Animation::ShouldRenderRichAnimation()) {
    return;
  }

  target_widget_bounds_ = GetWidget()->GetWindowBoundsInScreen();
  starting_widget_bounds_ =
      target_widget_bounds_ - gfx::Vector2d{0, kAnimationHeightOffset};
  height_animation_tween_ = gfx::Tween::ACCEL_5_70_DECEL_90;
  height_animation_.SetDuration(base::Milliseconds(kAnimationEntryDuration));
  height_animation_.Start();

  views::View* const bubble_frame_view = GetBubbleFrameView();
  bubble_frame_view->SetPaintToLayer();
  bubble_frame_view->layer()->SetFillsBoundsOpaquely(false);
  bubble_frame_view->SetTransform(
      GetScaleTransformation(bubble_frame_view->bounds()));
  bubble_frame_view->layer()->SetOpacity(0);
  GetDialogClientView()->SetBackground(
      views::CreateSolidBackground(ui::kColorToastBackgroundProminent));
  GetDialogClientView()->layer()->SetOpacity(0);
  views::AnimationBuilder()
      .Once()
      .SetDuration(base::Milliseconds(kAnimationEntryDuration))
      .SetTransform(bubble_frame_view, gfx::Transform(),
                    height_animation_tween_)
      .At(base::TimeDelta())
      .SetDuration(base::Milliseconds(50))
      .SetOpacity(bubble_frame_view, 1)
      .Then()
      .SetDuration(base::Milliseconds(150))
      .SetOpacity(GetDialogClientView(), 1);
}

void ToastView::Close(ToastCloseReason reason) {
  // Do not close if the menu is open - instead, remember the call to close it.
  if (menu_runner_) {
    pending_close_reason_ = reason;
    return;
  }

  // TODO(crbug.com/358610872): Log toast close reason metric.
  views::Widget::ClosedReason widget_closed_reason =
      views::Widget::ClosedReason::kUnspecified;
  switch (reason) {
    case ToastCloseReason::kCloseButton:
      widget_closed_reason = views::Widget::ClosedReason::kCloseButtonClicked;
      break;
    case ToastCloseReason::kActionButton:
      widget_closed_reason = views::Widget::ClosedReason::kAcceptButtonClicked;
      break;
    default:
      break;
  }

  toast_close_callback_.Run(reason);
  if (GetWidget()->IsVisible()) {
    AnimateOut(
        base::BindOnce(&views::Widget::CloseWithReason,
                       base::Unretained(GetWidget()), widget_closed_reason),
        reason != ToastCloseReason::kPreempted);
  } else {
    GetWidget()->CloseWithReason(widget_closed_reason);
  }
}

void ToastView::UpdateRenderToastOverWebContentsAndPaint(
    const bool render_toast_over_web_contents) {
  render_toast_over_web_contents_ = render_toast_over_web_contents;
  SizeToContents();
}

gfx::Rect ToastView::GetBubbleBounds() {
  views::View* anchor_view = GetAnchorView();
  if (!anchor_view) {
    return gfx::Rect();
  }

  const gfx::Size preferred_size =
      GetWidget()->GetContentsView()->GetPreferredSize();
  const gfx::Rect anchor_bounds = anchor_view->GetBoundsInScreen();

  // A wide toast in a narrow browser window needs to be compressed to fit.
  const int minimum_margin = ChromeLayoutProvider::Get()->GetDistanceMetric(
                                 DISTANCE_TOAST_BUBBLE_BROWSER_WINDOW_MARGIN) -
                             views::BubbleBorder::kShadowBlur;
  const int width =
      std::min(preferred_size.width(),
               std::max(anchor_bounds.width() - 2 * minimum_margin, 0));
  const int x = anchor_bounds.x() + ((anchor_bounds.width() - width) / 2);

  // Take bubble out of its original bounds to cross "line of death", unless in
  // fullscreen mode where the top container isn't rendered.
  const int y = anchor_bounds.bottom() - (render_toast_over_web_contents_
                                              ? views::BubbleBorder::kShadowBlur
                                              : (preferred_size.height() / 2));
  return gfx::Rect(x, y, width, preferred_size.height());
}

void ToastView::OnThemeChanged() {
  BubbleDialogDelegateView::OnThemeChanged();
  const auto* color_provider = GetColorProvider();
  if (image_override_ != nullptr && IsCompatibleImageSize(image_override_)) {
    icon_view_->SetImage(*image_override_);
  } else {
    icon_view_->SetImage(ui::ImageModel::FromVectorIcon(
        *icon_, color_provider->GetColor(ui::kColorToastForeground),
        GetIconSize()));
  }
}

void ToastView::AnimateOut(base::OnceClosure callback,
                           bool show_height_animation) {
  if (!gfx::Animation::ShouldRenderRichAnimation()) {
    std::move(callback).Run();
    return;
  }

  views::View* const bubble_frame_view = GetBubbleFrameView();
  if (!bubble_frame_view->layer()) {
    bubble_frame_view->SetPaintToLayer();
    bubble_frame_view->layer()->SetFillsBoundsOpaquely(false);
  }

  if (show_height_animation) {
    starting_widget_bounds_ = GetWidget()->GetWindowBoundsInScreen();
    target_widget_bounds_ =
        starting_widget_bounds_ - gfx::Vector2d{0, kAnimationHeightOffset};
    height_animation_tween_ = gfx::Tween::ACCEL_30_DECEL_20_85;
    height_animation_.SetDuration(base::Milliseconds(kAnimationExitDuration));
    height_animation_.Start();

    views::AnimationBuilder()
        .Once()
        .SetDuration(base::Milliseconds(kAnimationExitDuration))
        .SetTransform(bubble_frame_view,
                      GetScaleTransformation(bubble_frame_view->bounds()),
                      height_animation_tween_);
  }

  views::AnimationBuilder()
      .OnEnded(std::move(callback))
      .Once()
      .SetDuration(base::Milliseconds(100))
      .SetOpacity(GetDialogClientView(), 0)
      .Then()
      .SetDuration(base::Milliseconds(50))
      .SetOpacity(bubble_frame_view, 0);
}

void ToastView::OnMenuButtonClicked() {
  menu_runner_ = std::make_unique<views::MenuRunner>(
      menu_model_adapter_->CreateMenu(), views::MenuRunner::FIXED_ANCHOR);
  menu_runner_->RunMenuAt(GetWidget(),
                          static_cast<views::MenuButtonController*>(
                              menu_button_->button_controller()),
                          menu_button_->GetBoundsInScreen(),
                          views::MenuAnchorPosition::kTopRight,
                          ui::mojom::MenuSourceType::kNone);
}

void ToastView::OnMenuClosed() {
  menu_runner_.reset();
  if (pending_close_reason_) {
    Close(pending_close_reason_.value());
  }
}

BEGIN_METADATA(ToastView)
END_METADATA

}  // namespace toasts