// Copyright (c) 2021 Ryan Gonzalez.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.

#include "shell/browser/ui/views/client_frame_view_linux.h"

#include <algorithm>

#include "base/strings/utf_string_conversions.h"
#include "cc/paint/paint_filter.h"
#include "cc/paint/paint_flags.h"
#include "shell/browser/native_window_views.h"
#include "shell/browser/ui/electron_desktop_window_tree_host_linux.h"
#include "shell/browser/ui/views/frameless_view.h"
#include "ui/base/hit_test.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/font_list.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/skia_util.h"
#include "ui/gfx/text_constants.h"
#include "ui/gtk/gtk_compat.h"  // nogncheck
#include "ui/gtk/gtk_util.h"    // nogncheck
#include "ui/native_theme/native_theme.h"
#include "ui/strings/grit/ui_strings.h"
#include "ui/views/controls/button/image_button.h"
#include "ui/views/linux_ui/linux_ui.h"
#include "ui/views/linux_ui/nav_button_provider.h"
#include "ui/views/style/typography.h"
#include "ui/views/widget/widget.h"
#include "ui/views/window/frame_buttons.h"

namespace electron {

namespace {

// These values should be the same as Chromium uses.
constexpr int kResizeOutsideBorderSize = 10;
constexpr int kResizeInsideBoundsSize = 5;

}  // namespace

// static
const char ClientFrameViewLinux::kViewClassName[] = "ClientFrameView";

ClientFrameViewLinux::ClientFrameViewLinux()
    : theme_(ui::NativeTheme::GetInstanceForNativeUi()),
      nav_button_provider_(
          views::LinuxUI::instance()->CreateNavButtonProvider()),
      nav_buttons_{
          NavButton{views::NavButtonProvider::FrameButtonDisplayType::kClose,
                    views::FrameButton::kClose, &views::Widget::Close,
                    IDS_APP_ACCNAME_CLOSE, HTCLOSE},
          NavButton{views::NavButtonProvider::FrameButtonDisplayType::kMaximize,
                    views::FrameButton::kMaximize, &views::Widget::Maximize,
                    IDS_APP_ACCNAME_MAXIMIZE, HTMAXBUTTON},
          NavButton{views::NavButtonProvider::FrameButtonDisplayType::kRestore,
                    views::FrameButton::kMaximize, &views::Widget::Restore,
                    IDS_APP_ACCNAME_RESTORE, HTMAXBUTTON},
          NavButton{views::NavButtonProvider::FrameButtonDisplayType::kMinimize,
                    views::FrameButton::kMinimize, &views::Widget::Minimize,
                    IDS_APP_ACCNAME_MINIMIZE, HTMINBUTTON},
      },
      trailing_frame_buttons_{views::FrameButton::kMinimize,
                              views::FrameButton::kMaximize,
                              views::FrameButton::kClose} {
  for (auto& button : nav_buttons_) {
    button.button = new views::ImageButton();
    button.button->SetImageVerticalAlignment(views::ImageButton::ALIGN_MIDDLE);
    button.button->SetAccessibleName(
        l10n_util::GetStringUTF16(button.accessibility_id));
    AddChildView(button.button);
  }

  title_ = new views::Label();
  title_->SetSubpixelRenderingEnabled(false);
  title_->SetAutoColorReadabilityEnabled(false);
  title_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
  title_->SetVerticalAlignment(gfx::ALIGN_MIDDLE);
  title_->SetTextStyle(views::style::STYLE_TAB_ACTIVE);
  AddChildView(title_);

  native_theme_observer_.Observe(theme_);
  window_button_order_observer_.Observe(views::LinuxUI::instance());
}

ClientFrameViewLinux::~ClientFrameViewLinux() {
  views::LinuxUI::instance()->RemoveWindowButtonOrderObserver(this);
  theme_->RemoveObserver(this);
}

void ClientFrameViewLinux::Init(NativeWindowViews* window,
                                views::Widget* frame) {
  FramelessView::Init(window, frame);

  // Unretained() is safe because the subscription is saved into an instance
  // member and thus will be cancelled upon the instance's destruction.
  paint_as_active_changed_subscription_ =
      frame_->RegisterPaintAsActiveChangedCallback(base::BindRepeating(
          &ClientFrameViewLinux::PaintAsActiveChanged, base::Unretained(this)));

  auto* tree_host = static_cast<ElectronDesktopWindowTreeHostLinux*>(
      ElectronDesktopWindowTreeHostLinux::GetHostForWidget(
          window->GetAcceleratedWidget()));
  host_supports_client_frame_shadow_ = tree_host->SupportsClientFrameShadow();

  frame_provider_ = views::LinuxUI::instance()->GetWindowFrameProvider(
      !host_supports_client_frame_shadow_);

  UpdateWindowTitle();

  for (auto& button : nav_buttons_) {
    // Unretained() is safe because the buttons are added as children to, and
    // thus owned by, this view. Thus, the buttons themselves will be destroyed
    // when this view is destroyed, and the frame's life must never outlive the
    // view.
    button.button->SetCallback(
        base::BindRepeating(button.callback, base::Unretained(frame)));
  }

  UpdateThemeValues();
}

gfx::Insets ClientFrameViewLinux::GetBorderDecorationInsets() const {
  return frame_provider_->GetFrameThicknessDip();
}

gfx::Insets ClientFrameViewLinux::GetInputInsets() const {
  return gfx::Insets(
      host_supports_client_frame_shadow_ ? -kResizeOutsideBorderSize : 0);
}

gfx::Rect ClientFrameViewLinux::GetWindowContentBounds() const {
  gfx::Rect content_bounds = bounds();
  content_bounds.Inset(GetBorderDecorationInsets());
  return content_bounds;
}

SkRRect ClientFrameViewLinux::GetRoundedWindowContentBounds() const {
  SkRect rect = gfx::RectToSkRect(GetWindowContentBounds());
  SkRRect rrect;

  if (!frame_->IsMaximized()) {
    SkPoint round_point{theme_values_.window_border_radius,
                        theme_values_.window_border_radius};
    SkPoint radii[] = {round_point, round_point, {}, {}};
    rrect.setRectRadii(rect, radii);
  } else {
    rrect.setRect(rect);
  }

  return rrect;
}

void ClientFrameViewLinux::OnNativeThemeUpdated(
    ui::NativeTheme* observed_theme) {
  UpdateThemeValues();
}

void ClientFrameViewLinux::OnWindowButtonOrderingChange(
    const std::vector<views::FrameButton>& leading_buttons,
    const std::vector<views::FrameButton>& trailing_buttons) {
  leading_frame_buttons_ = leading_buttons;
  trailing_frame_buttons_ = trailing_buttons;

  InvalidateLayout();
}

int ClientFrameViewLinux::ResizingBorderHitTest(const gfx::Point& point) {
  return ResizingBorderHitTestImpl(
      point,
      GetBorderDecorationInsets() + gfx::Insets(kResizeInsideBoundsSize));
}

gfx::Rect ClientFrameViewLinux::GetBoundsForClientView() const {
  gfx::Rect client_bounds = bounds();
  if (!frame_->IsFullscreen()) {
    client_bounds.Inset(GetBorderDecorationInsets());
    client_bounds.Inset(
        gfx::Insets::TLBR(0, GetTitlebarBounds().height(), 0, 0));
  }
  return client_bounds;
}

gfx::Rect ClientFrameViewLinux::GetWindowBoundsForClientBounds(
    const gfx::Rect& client_bounds) const {
  gfx::Insets insets = bounds().InsetsFrom(GetBoundsForClientView());
  return gfx::Rect(std::max(0, client_bounds.x() - insets.left()),
                   std::max(0, client_bounds.y() - insets.top()),
                   client_bounds.width() + insets.width(),
                   client_bounds.height() + insets.height());
}

int ClientFrameViewLinux::NonClientHitTest(const gfx::Point& point) {
  int component = ResizingBorderHitTest(point);
  if (component != HTNOWHERE) {
    return component;
  }

  for (auto& button : nav_buttons_) {
    if (button.button->GetVisible() &&
        button.button->GetMirroredBounds().Contains(point)) {
      return button.hit_test_id;
    }
  }

  if (GetTitlebarBounds().Contains(point)) {
    return HTCAPTION;
  }

  return FramelessView::NonClientHitTest(point);
}

void ClientFrameViewLinux::GetWindowMask(const gfx::Size& size,
                                         SkPath* window_mask) {
  // Nothing to do here, as transparency is used for decorations, not masks.
}

void ClientFrameViewLinux::UpdateWindowTitle() {
  title_->SetText(base::UTF8ToUTF16(window_->GetTitle()));
}

void ClientFrameViewLinux::SizeConstraintsChanged() {
  InvalidateLayout();
}

gfx::Size ClientFrameViewLinux::CalculatePreferredSize() const {
  return SizeWithDecorations(FramelessView::CalculatePreferredSize());
}

gfx::Size ClientFrameViewLinux::GetMinimumSize() const {
  return SizeWithDecorations(FramelessView::GetMinimumSize());
}

gfx::Size ClientFrameViewLinux::GetMaximumSize() const {
  return SizeWithDecorations(FramelessView::GetMaximumSize());
}

void ClientFrameViewLinux::Layout() {
  FramelessView::Layout();

  if (frame_->IsFullscreen()) {
    // Just hide everything and return.
    for (NavButton& button : nav_buttons_) {
      button.button->SetVisible(false);
    }

    title_->SetVisible(false);
    return;
  }

  UpdateButtonImages();
  LayoutButtons();

  gfx::Rect title_bounds(GetTitlebarContentBounds());
  title_bounds.Inset(theme_values_.title_padding);

  title_->SetVisible(true);
  title_->SetBounds(title_bounds.x(), title_bounds.y(), title_bounds.width(),
                    title_bounds.height());
}

void ClientFrameViewLinux::OnPaint(gfx::Canvas* canvas) {
  if (!frame_->IsFullscreen()) {
    frame_provider_->PaintWindowFrame(canvas, GetLocalBounds(),
                                      GetTitlebarBounds().bottom(),
                                      ShouldPaintAsActive());
  }
}

const char* ClientFrameViewLinux::GetClassName() const {
  return kViewClassName;
}

void ClientFrameViewLinux::PaintAsActiveChanged() {
  UpdateThemeValues();
}

void ClientFrameViewLinux::UpdateThemeValues() {
  gtk::GtkCssContext window_context =
      gtk::AppendCssNodeToStyleContext({}, "GtkWindow#window.background.csd");
  gtk::GtkCssContext headerbar_context = gtk::AppendCssNodeToStyleContext(
      {}, "GtkHeaderBar#headerbar.default-decoration.titlebar");
  gtk::GtkCssContext title_context = gtk::AppendCssNodeToStyleContext(
      headerbar_context, "GtkLabel#label.title");
  gtk::GtkCssContext button_context = gtk::AppendCssNodeToStyleContext(
      headerbar_context, "GtkButton#button.image-button");

  gtk_style_context_set_parent(headerbar_context, window_context);
  gtk_style_context_set_parent(title_context, headerbar_context);
  gtk_style_context_set_parent(button_context, headerbar_context);

  // ShouldPaintAsActive asks the widget, so assume active if the widget is not
  // set yet.
  if (GetWidget() != nullptr && !ShouldPaintAsActive()) {
    gtk_style_context_set_state(window_context, GTK_STATE_FLAG_BACKDROP);
    gtk_style_context_set_state(headerbar_context, GTK_STATE_FLAG_BACKDROP);
    gtk_style_context_set_state(title_context, GTK_STATE_FLAG_BACKDROP);
    gtk_style_context_set_state(button_context, GTK_STATE_FLAG_BACKDROP);
  }

  theme_values_.window_border_radius = frame_provider_->GetTopCornerRadiusDip();

  gtk::GtkStyleContextGet(headerbar_context, "min-height",
                          &theme_values_.titlebar_min_height, nullptr);
  theme_values_.titlebar_padding =
      gtk::GtkStyleContextGetPadding(headerbar_context);

  theme_values_.title_color = gtk::GtkStyleContextGetColor(title_context);
  theme_values_.title_padding = gtk::GtkStyleContextGetPadding(title_context);

  gtk::GtkStyleContextGet(button_context, "min-height",
                          &theme_values_.button_min_size, nullptr);
  theme_values_.button_padding = gtk::GtkStyleContextGetPadding(button_context);

  title_->SetEnabledColor(theme_values_.title_color);

  InvalidateLayout();
  SchedulePaint();
}

views::NavButtonProvider::FrameButtonDisplayType
ClientFrameViewLinux::GetButtonTypeToSkip() const {
  return frame_->IsMaximized()
             ? views::NavButtonProvider::FrameButtonDisplayType::kMaximize
             : views::NavButtonProvider::FrameButtonDisplayType::kRestore;
}

void ClientFrameViewLinux::UpdateButtonImages() {
  nav_button_provider_->RedrawImages(theme_values_.button_min_size,
                                     frame_->IsMaximized(),
                                     ShouldPaintAsActive());

  views::NavButtonProvider::FrameButtonDisplayType skip_type =
      GetButtonTypeToSkip();

  for (NavButton& button : nav_buttons_) {
    if (button.type == skip_type) {
      continue;
    }

    for (size_t state_id = 0; state_id < views::Button::STATE_COUNT;
         state_id++) {
      views::Button::ButtonState state =
          static_cast<views::Button::ButtonState>(state_id);
      button.button->SetImage(
          state, nav_button_provider_->GetImage(button.type, state));
    }
  }
}

void ClientFrameViewLinux::LayoutButtons() {
  for (NavButton& button : nav_buttons_) {
    button.button->SetVisible(false);
  }

  gfx::Rect remaining_content_bounds = GetTitlebarContentBounds();
  LayoutButtonsOnSide(ButtonSide::kLeading, &remaining_content_bounds);
  LayoutButtonsOnSide(ButtonSide::kTrailing, &remaining_content_bounds);
}

void ClientFrameViewLinux::LayoutButtonsOnSide(
    ButtonSide side,
    gfx::Rect* remaining_content_bounds) {
  views::NavButtonProvider::FrameButtonDisplayType skip_type =
      GetButtonTypeToSkip();

  std::vector<views::FrameButton> frame_buttons;

  switch (side) {
    case ButtonSide::kLeading:
      frame_buttons = leading_frame_buttons_;
      break;
    case ButtonSide::kTrailing:
      frame_buttons = trailing_frame_buttons_;
      // We always lay buttons out going from the edge towards the center, but
      // they are given to us as left-to-right, so reverse them.
      std::reverse(frame_buttons.begin(), frame_buttons.end());
      break;
    default:
      NOTREACHED();
  }

  for (views::FrameButton frame_button : frame_buttons) {
    auto* button = std::find_if(
        nav_buttons_.begin(), nav_buttons_.end(), [&](const NavButton& test) {
          return test.type != skip_type && test.frame_button == frame_button;
        });
    CHECK(button != nav_buttons_.end())
        << "Failed to find frame button: " << static_cast<int>(frame_button);

    if (button->type == skip_type) {
      continue;
    }

    button->button->SetVisible(true);

    int button_width = theme_values_.button_min_size;
    int next_button_offset =
        button_width + nav_button_provider_->GetInterNavButtonSpacing();

    int x_position = 0;
    gfx::Insets inset_after_placement;

    switch (side) {
      case ButtonSide::kLeading:
        x_position = remaining_content_bounds->x();
        inset_after_placement.set_left(next_button_offset);
        break;
      case ButtonSide::kTrailing:
        x_position = remaining_content_bounds->right() - button_width;
        inset_after_placement.set_right(next_button_offset);
        break;
      default:
        NOTREACHED();
    }

    button->button->SetBounds(x_position, remaining_content_bounds->y(),
                              button_width, remaining_content_bounds->height());
    remaining_content_bounds->Inset(inset_after_placement);
  }
}

gfx::Rect ClientFrameViewLinux::GetTitlebarBounds() const {
  if (frame_->IsFullscreen()) {
    return gfx::Rect();
  }

  int font_height = gfx::FontList().GetHeight();
  int titlebar_height =
      std::max(font_height, theme_values_.titlebar_min_height) +
      GetTitlebarContentInsets().height();

  gfx::Insets decoration_insets = GetBorderDecorationInsets();

  // We add the inset height here, so the .Inset() that follows won't reduce it
  // to be too small.
  gfx::Rect titlebar(width(), titlebar_height + decoration_insets.height());
  titlebar.Inset(decoration_insets);
  return titlebar;
}

gfx::Insets ClientFrameViewLinux::GetTitlebarContentInsets() const {
  return theme_values_.titlebar_padding +
         nav_button_provider_->GetTopAreaSpacing();
}

gfx::Rect ClientFrameViewLinux::GetTitlebarContentBounds() const {
  gfx::Rect titlebar(GetTitlebarBounds());
  titlebar.Inset(GetTitlebarContentInsets());
  return titlebar;
}

gfx::Size ClientFrameViewLinux::SizeWithDecorations(gfx::Size size) const {
  gfx::Insets decoration_insets = GetBorderDecorationInsets();

  size.Enlarge(0, GetTitlebarBounds().height());
  size.Enlarge(decoration_insets.width(), decoration_insets.height());
  return size;
}

}  // namespace electron