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

#include "ash/frame/wide_frame_view.h"

#include <memory>

#include "ash/frame/non_client_frame_view_ash.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/screen_util.h"
#include "ash/shell.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/window_state.h"
#include "ash/wm/wm_event.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/user_metrics.h"
#include "chromeos/ui/frame/caption_buttons/frame_caption_button_container_view.h"
#include "chromeos/ui/frame/default_frame_header.h"
#include "chromeos/ui/frame/header_view.h"
#include "chromeos/ui/frame/immersive/immersive_fullscreen_controller.h"
#include "ui/aura/window.h"
#include "ui/aura/window_targeter.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/events/types/event_type.h"
#include "ui/views/widget/widget.h"
#include "ui/views/window/caption_button_layout_constants.h"

namespace ash {
namespace {

using ::chromeos::ImmersiveFullscreenController;

class WideFrameTargeter : public aura::WindowTargeter {
 public:
  explicit WideFrameTargeter(chromeos::HeaderView* header_view)
      : header_view_(header_view) {}

  WideFrameTargeter(const WideFrameTargeter&) = delete;
  WideFrameTargeter& operator=(const WideFrameTargeter&) = delete;

  ~WideFrameTargeter() override = default;

  // aura::WindowTargeter:
  bool GetHitTestRects(aura::Window* target,
                       gfx::Rect* hit_test_rect_mouse,
                       gfx::Rect* hit_test_rect_touch) const override {
    if (header_view_->in_immersive_mode() && !header_view_->is_revealed()) {
      aura::Window* source = header_view_->GetWidget()->GetNativeWindow();
      *hit_test_rect_mouse = source->bounds();
      aura::Window::ConvertRectToTarget(source, target->parent(),
                                        hit_test_rect_mouse);
      hit_test_rect_mouse->set_y(target->bounds().y());
      hit_test_rect_mouse->set_height(1);
      hit_test_rect_touch->SetRect(0, 0, 0, 0);
      return true;
    }
    return aura::WindowTargeter::GetHitTestRects(target, hit_test_rect_mouse,
                                                 hit_test_rect_touch);
  }

 private:
  raw_ptr<chromeos::HeaderView> header_view_;
};

}  // namespace

// static
gfx::Rect WideFrameView::GetFrameBounds(views::Widget* target) {
  static const int kFrameHeight =
      views::GetCaptionButtonLayoutSize(
          views::CaptionButtonLayoutSize::kNonBrowserCaption)
          .height();
  aura::Window* target_window = target->GetNativeWindow();
  gfx::Rect bounds =
      screen_util::GetIdealBoundsForMaximizedOrFullscreenOrPinnedState(
          target_window);

  bounds.set_height(kFrameHeight);
  return bounds;
}

void WideFrameView::Init(ImmersiveFullscreenController* controller) {
  DCHECK(target_);
  controller->Init(this, target_, header_view_);
}

void WideFrameView::SetCaptionButtonModel(
    std::unique_ptr<chromeos::CaptionButtonModel> model) {
  header_view_->caption_button_container()->SetModel(std::move(model));
  header_view_->UpdateCaptionButtons();
}

WideFrameView::WideFrameView(views::Widget* target)
    : target_(target),
      frame_context_menu_controller_(
          std::make_unique<FrameContextMenuController>(target_, this)) {
  aura::Window* target_window = target->GetNativeWindow();
  target_window->AddObserver(this);
  // Use the HeaderView itself as a frame view because WideFrameView is
  // is the frame only.
  header_view_ = AddChildView(
      std::make_unique<chromeos::HeaderView>(target, /*frame view=*/nullptr));
  header_view_->Init();
  GetTargetHeaderView()->SetShouldPaintHeader(false);
  header_view_->set_context_menu_controller(
      frame_context_menu_controller_.get());

  views::Widget::InitParams params(
      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET,
      views::Widget::InitParams::TYPE_POPUP);
  params.delegate = this;
  params.bounds = GetFrameBounds(target);
  params.name = "WideFrameView";
  params.parent = target->GetNativeWindow();
  // Setup Opacity Control.
  // WideFrame should be used only when the rounded corner is not necessary.
  params.opacity = views::Widget::InitParams::WindowOpacity::kOpaque;
  auto widget = std::make_unique<views::Widget>();
  widget->Init(std::move(params));
  widget_ = std::move(widget);

  aura::Window* window = widget_->GetNativeWindow();
  // Overview normally clips the caption container which exists on the same
  // window. But this WideFrameView exists as a separate window, which we hide
  // in overview using the `kHideInOverviewKey` property. However, we still want
  // to show it in the desks mini_views.
  window->SetProperty(kHideInOverviewKey, true);
  window->SetProperty(kForceVisibleInMiniViewKey, true);
  window->SetEventTargeter(std::make_unique<WideFrameTargeter>(header_view()));
  set_owned_by_client(OwnedByClientPassKey());
  WindowState::Get(window)->set_allow_set_bounds_direct(true);

  paint_as_active_subscription_ =
      target_->RegisterPaintAsActiveChangedCallback(base::BindRepeating(
          &WideFrameView::PaintAsActiveChanged, base::Unretained(this)));
  PaintAsActiveChanged();
}

WideFrameView::~WideFrameView() {
  header_view_->set_context_menu_controller(nullptr);
  if (widget_)
    widget_->CloseNow();
  if (target_) {
    chromeos::HeaderView* target_header_view = GetTargetHeaderView();
    target_header_view->SetShouldPaintHeader(true);
    target_header_view->GetFrameHeader()->UpdateFrameHeaderKey();
    target_->GetNativeWindow()->RemoveObserver(this);
  }
}

void WideFrameView::Layout(PassKey) {
  int onscreen_height = header_view_->GetPreferredOnScreenHeight();
  if (onscreen_height == 0 || !GetVisible()) {
    header_view_->SetVisible(false);
  } else {
    const int height = header_view_->GetPreferredHeight();
    header_view_->SetBounds(0, onscreen_height - height, width(), height);
    header_view_->SetVisible(true);
  }
}

void WideFrameView::OnMouseEvent(ui::MouseEvent* event) {
  if (event->IsOnlyLeftMouseButton()) {
    if ((event->flags() & ui::EF_IS_DOUBLE_CLICK) &&
        event->type() == ui::EventType::kMousePressed) {
      base::RecordAction(
          base::UserMetricsAction("Caption_ClickTogglesMaximize"));
      const WMEvent wm_event(WM_EVENT_TOGGLE_MAXIMIZE_CAPTION);
      WindowState::Get(target_->GetNativeWindow())->OnWMEvent(&wm_event);
    }
    event->SetHandled();
  }
}

void WideFrameView::OnWindowDestroying(aura::Window* window) {
  window->RemoveObserver(this);
  target_ = nullptr;
}

void WideFrameView::OnDisplayMetricsChanged(const display::Display& display,
                                            uint32_t changed_metrics) {
  aura::Window* target_window = target_->GetNativeWindow();
  // The target window is detached from the tree when the window is being moved
  // to another desks, or another display, and it may trigger the display
  // metrics change if the target window is in fullscreen. Do not try to layout
  // in this case. The it'll be layout when the window is added back.
  // (crbug.com/1267128)
  if (!target_window->GetRootWindow())
    return;

  display::Screen* screen = display::Screen::GetScreen();
  if (screen->GetDisplayNearestWindow(target_->GetNativeWindow()).id() !=
          display.id() ||
      !widget_) {
    return;
  }
  DCHECK(target_);

  // Ignore if this is called when the targe window state is nor proper
  // state. This can happen when switching the state to other states, in which
  // case, the wide frame will be removed.
  if (!WindowState::Get(target_window)->IsMaximizedOrFullscreenOrPinned()) {
    return;
  }

  GetWidget()->SetBounds(GetFrameBounds(target_));
}

void WideFrameView::OnImmersiveRevealStarted() {
  header_view_->OnImmersiveRevealStarted();
}

void WideFrameView::OnImmersiveRevealEnded() {
  header_view_->OnImmersiveRevealEnded();
}

void WideFrameView::OnImmersiveFullscreenEntered() {
  header_view_->OnImmersiveFullscreenEntered();
  widget_->GetNativeWindow()->SetTransparent(true);
  if (target_)
    GetTargetHeaderView()->OnImmersiveFullscreenEntered();
}

void WideFrameView::OnImmersiveFullscreenExited() {
  header_view_->OnImmersiveFullscreenExited();
  widget_->GetNativeWindow()->SetTransparent(false);
  if (target_)
    GetTargetHeaderView()->OnImmersiveFullscreenExited();
  DeprecatedLayoutImmediately();
}

void WideFrameView::SetVisibleFraction(double visible_fraction) {
  header_view_->SetVisibleFraction(visible_fraction);
}

std::vector<gfx::Rect> WideFrameView::GetVisibleBoundsInScreen() const {
  return header_view_->GetVisibleBoundsInScreen();
}

bool WideFrameView::ShouldShowContextMenu(
    View* source,
    const gfx::Point& screen_coords_point) {
  gfx::Point point_in_header_coords(screen_coords_point);
  views::View::ConvertPointToTarget(this, header_view_,
                                    &point_in_header_coords);
  return header_view_->HitTestRect(
      gfx::Rect(point_in_header_coords, gfx::Size(1, 1)));
}

chromeos::HeaderView* WideFrameView::GetTargetHeaderView() {
  auto* frame_view = static_cast<NonClientFrameViewAsh*>(
      target_->non_client_view()->frame_view());
  return frame_view->GetHeaderView();
}

void WideFrameView::PaintAsActiveChanged() {
  header_view_->GetFrameHeader()->SetPaintAsActive(
      target_->ShouldPaintAsActive());
}

}  // namespace ash