// Copyright 2015 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/android/compositor/layer/overlay_panel_layer.h"

#include "cc/resources/scoped_ui_resource.h"
#include "cc/slim/layer.h"
#include "cc/slim/nine_patch_layer.h"
#include "cc/slim/solid_color_layer.h"
#include "cc/slim/ui_resource_layer.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/android/resources/nine_patch_resource.h"
#include "ui/android/resources/resource_manager.h"
#include "ui/base/l10n/l10n_util_android.h"
#include "ui/gfx/color_utils.h"

namespace android {

scoped_refptr<cc::slim::Layer> OverlayPanelLayer::GetIconLayer() {
  if (panel_icon_resource_id_ == kInvalidResourceID)
    return nullptr;
  ui::Resource* panel_icon_resource = resource_manager_->GetResource(
      ui::ANDROID_RESOURCE_TYPE_STATIC, panel_icon_resource_id_);
  DCHECK(panel_icon_resource);

  if (panel_icon_->parent() != layer_) {
    layer_->AddChild(panel_icon_);
  }

  panel_icon_->SetUIResourceId(panel_icon_resource->ui_resource()->id());
  panel_icon_->SetBounds(panel_icon_resource->size());

  return panel_icon_;
}

void OverlayPanelLayer::AddBarTextLayer(
    scoped_refptr<cc::slim::Layer> text_layer) {
  if (text_container_->parent() != layer_)
    layer_->AddChild(text_container_);
  if (text_layer->parent() != text_container_)
    text_container_->AddChild(text_layer);
}

void OverlayPanelLayer::SetResourceIds(int bar_text_resource_id,
                                       int panel_shadow_resource_id,
                                       int rounded_bar_top_resource_id,
                                       int bar_shadow_resource_id,
                                       int panel_icon_resource_id,
                                       int drag_handlebar_resource_id,
                                       int open_tab_icon_resource_id,
                                       int close_icon_resource_id) {
  bar_text_resource_id_ = bar_text_resource_id;
  panel_shadow_resource_id_ = panel_shadow_resource_id;
  rounded_bar_top_resource_id_ = rounded_bar_top_resource_id;
  bar_shadow_resource_id_ = bar_shadow_resource_id;
  panel_icon_resource_id_ = panel_icon_resource_id;
  drag_handlebar_resource_id_ = drag_handlebar_resource_id;
  open_tab_icon_resource_id_ = open_tab_icon_resource_id;
  close_icon_resource_id_ = close_icon_resource_id;
}

void OverlayPanelLayer::SetProperties(
    float dp_to_px,
    const scoped_refptr<cc::slim::Layer>& content_layer,
    float content_offset_y,
    float panel_x,
    float panel_y,
    float panel_width,
    float panel_height,
    int bar_background_color,
    float bar_margin_side,
    float bar_margin_top,
    float bar_margin_bottom,
    float bar_height,
    float bar_offset_y,
    float bar_text_opacity,
    bool bar_border_visible,
    float bar_border_height,
    int icon_tint,
    int drag_handlebar_tint,
    float icon_opacity,
    int separator_line_color,
    float in_bar_related_searches_height) {
  // Round values to avoid pixel gap between layers.
  bar_height = floor(bar_height);

  // ---------------------------------------------------------------------------
  // Content setup, to center in space below drag handle (when present).
  // When Related Searches are shown in the Bar they appear below the rest of
  // this content.
  // ---------------------------------------------------------------------------
  float bar_top_y = bar_offset_y;
  float bar_bottom = bar_top_y + bar_height;

  bool is_rtl = l10n_util::IsLayoutRtl();

  int content_top_y = bar_top_y;
  int content_height = bar_height - in_bar_related_searches_height;
  int rounded_top_height = 0;
  gfx::Size rounded_bar_top_size;
  gfx::PointF rounded_bar_top_position;

  ui::NinePatchResource* rounded_bar_top_resource = nullptr;
  content_top_y += bar_margin_top;
  content_height -= bar_margin_top;
  content_height -= bar_margin_bottom;

  rounded_bar_top_resource =
      ui::NinePatchResource::From(resource_manager_->GetStaticResourceWithTint(
          rounded_bar_top_resource_id_, bar_background_color));

  rounded_bar_top_size = gfx::Size(rounded_bar_top_resource->size().width(),
                                   rounded_bar_top_resource->size().height());

  // TODO(donnd): fix correctly.
  const int vertical_fudge_factor = 2;  // Create an overlap to avoid a seam.
  rounded_top_height = rounded_bar_top_resource->size().height();

  rounded_bar_top_position =
      gfx::PointF(-rounded_bar_top_resource->padding().x(),
                  bar_top_y + vertical_fudge_factor);

  // ---------------------------------------------------------------------------
  // Panel Shadow
  // ---------------------------------------------------------------------------
  if (panel_shadow_resource_id_ != kInvalidResourceID) {
    if (panel_shadow_->parent() != layer_) {
      layer_->InsertChild(panel_shadow_, 0);
    }
    ui::NinePatchResource* panel_shadow_resource =
        ui::NinePatchResource::From(resource_manager_->GetResource(
            ui::ANDROID_RESOURCE_TYPE_STATIC, panel_shadow_resource_id_));
    DCHECK(panel_shadow_resource);

    gfx::Size shadow_res_size = panel_shadow_resource->size();
    panel_shadow_->SetUIResourceId(panel_shadow_resource->ui_resource()->id());
    panel_shadow_->SetAperture(panel_shadow_resource->aperture());

    DCHECK(rounded_bar_top_resource);

    int shadow_thickness = shadow_res_size.height() - rounded_top_height;

    gfx::Size shadow_bounds(panel_width + (shadow_thickness * 2),
                            panel_height + shadow_thickness);
    panel_shadow_->SetBounds(shadow_bounds);
    panel_shadow_->SetBorder(panel_shadow_resource->Border(shadow_bounds));
    gfx::PointF shadow_position(-shadow_thickness,
                                bar_top_y - shadow_thickness);
    panel_shadow_->SetPosition(shadow_position);
  }

  // ---------------------------------------------------------------------------
  // Rounded Bar Top
  // ---------------------------------------------------------------------------

  DCHECK(rounded_bar_top_resource_id_ != kInvalidResourceID);
  rounded_bar_top_->SetIsDrawable(true);

  DCHECK(rounded_bar_top_resource);

  gfx::Size bounds(panel_width, rounded_bar_top_resource->size().height());

  rounded_bar_top_->SetUIResourceId(
      rounded_bar_top_resource->ui_resource()->id());
  rounded_bar_top_->SetBounds(bounds);
  rounded_bar_top_->SetAperture(rounded_bar_top_resource->aperture());
  rounded_bar_top_->SetBorder(rounded_bar_top_resource->Border(bounds));
  rounded_bar_top_->SetPosition(rounded_bar_top_position);
  rounded_bar_top_->SetOpacity(1.0f);

  // ---------------------------------------------------------------------------
  // Bar Background
  // ---------------------------------------------------------------------------
  // If we have a rounded_bar_top then it draws the top part of the bar
  // background.
  gfx::Size background_size(panel_width, bar_height - rounded_top_height);
  bar_background_->SetBounds(background_size);
  bar_background_->SetPosition(
      gfx::PointF(0.f, bar_top_y + rounded_top_height));
  // TODO(crbug.com/40219248): Remove FromColor and make all SkColor4f.
  bar_background_->SetBackgroundColor(
      SkColor4f::FromColor(bar_background_color));

  // ---------------------------------------------------------------------------
  // Bar Text
  // ---------------------------------------------------------------------------
  ui::Resource* bar_text_resource = resource_manager_->GetResource(
      ui::ANDROID_RESOURCE_TYPE_DYNAMIC, bar_text_resource_id_);

  if (bar_text_resource) {
    // Centers the text vertically in the section of the Search Bar below the
    // drag handle.
    float bar_padding_top = content_top_y + content_height / 2 -
                            bar_text_resource->size().height() / 2;
    bar_text_->SetUIResourceId(bar_text_resource->ui_resource()->id());
    bar_text_->SetBounds(bar_text_resource->size());
    bar_text_->SetPosition(gfx::PointF(0.f, bar_padding_top));
    bar_text_->SetOpacity(bar_text_opacity);
  }

  // ---------------------------------------------------------------------------
  // Panel Icon
  // ---------------------------------------------------------------------------
  scoped_refptr<cc::slim::Layer> icon_layer = GetIconLayer();
  if (icon_layer) {
    // If the icon is not the default width, add or remove padding so it appears
    // centered.
    float icon_padding = (kDefaultIconWidthDp * dp_to_px -
        icon_layer->bounds().width()) / 2.0f;

    // Positions the Icon at the start of the bar.
    float icon_x;
    if (is_rtl) {
      icon_x = panel_width - icon_layer->bounds().width() -
          (bar_margin_side + icon_padding);
    } else {
      icon_x = bar_margin_side + icon_padding;
    }

    // Centers the Icon vertically in the bar.
    float icon_y =
        content_top_y + content_height / 2 - icon_layer->bounds().height() / 2;

    icon_layer->SetPosition(gfx::PointF(icon_x, icon_y));
  }

  // ---------------------------------------------------------------------------
  // Drag Handlebar
  // ---------------------------------------------------------------------------
  if (drag_handlebar_resource_id_ != kInvalidResourceID) {
    if (drag_handlebar_->parent() != layer_)
      layer_->AddChild(drag_handlebar_);

    ui::Resource* drag_handlebar_resource =
        resource_manager_->GetStaticResourceWithTint(
            drag_handlebar_resource_id_, drag_handlebar_tint);
    drag_handlebar_->SetUIResourceId(
        drag_handlebar_resource->ui_resource()->id());
    drag_handlebar_->SetBounds(drag_handlebar_resource->size());
    float drag_handlebar_left =
        panel_width / 2 - drag_handlebar_resource->size().width() / 2;
    float drag_handlebar_top = bar_top_y + bar_margin_top -
                               drag_handlebar_resource->size().height() / 2;
    drag_handlebar_->SetPosition(
        gfx::PointF(drag_handlebar_left, drag_handlebar_top));
  }

  // ---------------------------------------------------------------------------
  // Close Icon
  // ---------------------------------------------------------------------------
  int close_icon_width = 0;
  float close_icon_left = 0.f;
  // Positions the icon at the end of the bar.
  if (is_rtl) {
    close_icon_left = bar_margin_side;
  } else {
    close_icon_left = panel_width - bar_margin_side;
  }
  if (close_icon_resource_id_ != kInvalidResourceID) {
    // Grab the Close Icon resource.
    ui::Resource* close_icon_resource =
        resource_manager_->GetStaticResourceWithTint(close_icon_resource_id_,
                                                     icon_tint);

    // Positions the icon at the end of the bar.
    close_icon_width = close_icon_resource->size().width();
    if (!is_rtl) {
      close_icon_left = close_icon_left - close_icon_width;
    }

    // Centers the Close Icon vertically in the bar.
    float close_icon_top = content_top_y + content_height / 2 -
                           close_icon_resource->size().height() / 2;
    close_icon_->SetUIResourceId(close_icon_resource->ui_resource()->id());
    close_icon_->SetBounds(close_icon_resource->size());
    close_icon_->SetPosition(gfx::PointF(close_icon_left, close_icon_top));
    close_icon_->SetOpacity(icon_opacity);
  }

  // ---------------------------------------------------------------------------
  // Open Tab icon
  // ---------------------------------------------------------------------------
  if (open_tab_icon_resource_id_ != kInvalidResourceID) {
    ui::Resource* open_tab_icon_resource =
        resource_manager_->GetStaticResourceWithTint(open_tab_icon_resource_id_,
                                                     icon_tint);
    // Positions the icon at the end of the bar.
    float open_tab_top = content_top_y + content_height / 2 -
                         open_tab_icon_resource->size().height() / 2;
    float open_tab_left;
    float spacing_between_icons = 2 * bar_margin_side;
    float margin_from_close_icon = close_icon_width + spacing_between_icons;
    if (is_rtl) {
      open_tab_left = close_icon_resource_id_ == kInvalidResourceID
                          ? close_icon_left
                          : close_icon_left + margin_from_close_icon;
    } else {
      open_tab_left = close_icon_left - margin_from_close_icon;
    }

    open_tab_icon_->SetUIResourceId(
        open_tab_icon_resource->ui_resource()->id());
    open_tab_icon_->SetBounds(open_tab_icon_resource->size());
    open_tab_icon_->SetPosition(gfx::PointF(open_tab_left, open_tab_top));
    open_tab_icon_->SetOpacity(icon_opacity);
  }

  // ---------------------------------------------------------------------------
  // Overlay Web Content
  // ---------------------------------------------------------------------------
  content_container_->SetPosition(
      gfx::PointF(0.f, content_offset_y));
  content_container_->SetBounds(gfx::Size(panel_width, panel_height));
  content_container_->SetBackgroundColor(
      SkColor4f::FromColor(bar_background_color));
  if (content_layer) {
    if (content_layer->parent() != content_container_)
      content_container_->AddChild(content_layer);
  } else {
    content_container_->RemoveAllChildren();
  }

  // ---------------------------------------------------------------------------
  // Bar Shadow
  // ---------------------------------------------------------------------------
  ui::Resource* bar_shadow_resource = resource_manager_->GetResource(
      ui::ANDROID_RESOURCE_TYPE_STATIC, bar_shadow_resource_id_);

  if (bar_shadow_resource) {
    if (bar_shadow_->parent() != layer_)
      layer_->AddChild(bar_shadow_);

    int shadow_height = bar_shadow_resource->size().height();
    gfx::Size shadow_size(panel_width, shadow_height);

    bar_shadow_->SetUIResourceId(bar_shadow_resource->ui_resource()->id());
    bar_shadow_->SetBounds(shadow_size);
    bar_shadow_->SetPosition(gfx::PointF(0.f, bar_bottom));
    bar_shadow_->SetOpacity(1.0f);
  }

  // ---------------------------------------------------------------------------
  // Panel
  // ---------------------------------------------------------------------------
  layer_->SetPosition(gfx::PointF(panel_x, panel_y));

  // ---------------------------------------------------------------------------
  // Bar border
  // ---------------------------------------------------------------------------
  if (bar_border_visible) {
    gfx::Size bar_border_size(panel_width,
                                     bar_border_height);
    float border_y = bar_bottom - bar_border_height;
    bar_border_->SetBounds(bar_border_size);
    bar_border_->SetPosition(
        gfx::PointF(0.f, border_y));
    bar_border_->SetBackgroundColor(SkColor4f::FromColor(separator_line_color));
    if (bar_border_->parent() != layer_)
      layer_->AddChild(bar_border_);
  } else if (bar_border_.get() && bar_border_->parent()) {
    bar_border_->RemoveFromParent();
  }
}

void OverlayPanelLayer::SetProgressBar(int progress_bar_background_resource_id,
                                       int progress_bar_background_tint,
                                       int progress_bar_resource_id,
                                       int progress_bar_tint,
                                       bool progress_bar_visible,
                                       float progress_bar_position_y,
                                       float progress_bar_height,
                                       float progress_bar_opacity,
                                       float progress_bar_completion,
                                       float panel_width) {
  bool should_render_progress_bar =
      progress_bar_visible && progress_bar_opacity > 0.f;

  if (should_render_progress_bar) {
    ui::NinePatchResource* progress_bar_background_resource =
        ui::NinePatchResource::From(
            resource_manager_->GetStaticResourceWithTint(
                progress_bar_background_resource_id,
                progress_bar_background_tint));
    ui::NinePatchResource* progress_bar_resource = ui::NinePatchResource::From(
        resource_manager_->GetStaticResourceWithTint(progress_bar_resource_id,
                                                     progress_bar_tint));

    DCHECK(progress_bar_background_resource);
    DCHECK(progress_bar_resource);

    // Progress Bar Background
    if (progress_bar_background_->parent() != layer_)
      layer_->AddChild(progress_bar_background_);

    float progress_bar_y = progress_bar_position_y - progress_bar_height;
    gfx::Size progress_bar_background_size(panel_width, progress_bar_height);

    progress_bar_background_->SetUIResourceId(
        progress_bar_background_resource->ui_resource()->id());
    progress_bar_background_->SetBorder(
        progress_bar_background_resource->Border(progress_bar_background_size));
    progress_bar_background_->SetAperture(
        progress_bar_background_resource->aperture());
    progress_bar_background_->SetBounds(progress_bar_background_size);
    progress_bar_background_->SetPosition(gfx::PointF(0.f, progress_bar_y));
    progress_bar_background_->SetOpacity(progress_bar_opacity);

    // Progress Bar
    if (progress_bar_->parent() != layer_)
      layer_->AddChild(progress_bar_);

    float progress_bar_width = floor(panel_width * progress_bar_completion);
    gfx::Size progress_bar_size(progress_bar_width, progress_bar_height);
    progress_bar_->SetUIResourceId(progress_bar_resource->ui_resource()->id());
    progress_bar_->SetBorder(progress_bar_resource->Border(progress_bar_size));
    progress_bar_->SetAperture(progress_bar_resource->aperture());
    progress_bar_->SetBounds(progress_bar_size);
    progress_bar_->SetPosition(gfx::PointF(0.f, progress_bar_y));
    progress_bar_->SetOpacity(progress_bar_opacity);
  } else {
    // Removes Progress Bar and its Background from the Layer Tree.
    if (progress_bar_background_.get() && progress_bar_background_->parent())
      progress_bar_background_->RemoveFromParent();

    if (progress_bar_.get() && progress_bar_->parent())
      progress_bar_->RemoveFromParent();
  }
}

OverlayPanelLayer::OverlayPanelLayer(ui::ResourceManager* resource_manager)
    : resource_manager_(resource_manager),
      layer_(cc::slim::Layer::Create()),
      panel_shadow_(cc::slim::NinePatchLayer::Create()),
      rounded_bar_top_(cc::slim::NinePatchLayer::Create()),
      bar_background_(cc::slim::SolidColorLayer::Create()),
      bar_text_(cc::slim::UIResourceLayer::Create()),
      bar_shadow_(cc::slim::UIResourceLayer::Create()),
      panel_icon_(cc::slim::UIResourceLayer::Create()),
      drag_handlebar_(cc::slim::UIResourceLayer::Create()),
      open_tab_icon_(cc::slim::UIResourceLayer::Create()),
      close_icon_(cc::slim::UIResourceLayer::Create()),
      content_container_(cc::slim::SolidColorLayer::Create()),
      text_container_(cc::slim::Layer::Create()),
      bar_border_(cc::slim::SolidColorLayer::Create()),
      progress_bar_(cc::slim::NinePatchLayer::Create()),
      progress_bar_background_(cc::slim::NinePatchLayer::Create()) {
  // Background colors for each widget are set in SetProperties, where variable
  // colors are available.
  layer_->SetMasksToBounds(false);
  layer_->SetIsDrawable(true);

  // Panel Shadow -- the shadow around all sides of the panel.
  panel_shadow_->SetIsDrawable(true);
  panel_shadow_->SetFillCenter(false);

  // Rounded Bar Top
  // Puts the layer near the bottom -- we'll decide if it's actually drawable
  // later.
  rounded_bar_top_->SetIsDrawable(false);
  layer_->AddChild(rounded_bar_top_);

  // Bar Background
  bar_background_->SetIsDrawable(true);
  layer_->AddChild(bar_background_);

  // Bar Text
  bar_text_->SetIsDrawable(true);
  AddBarTextLayer(bar_text_);

  // Panel Icon
  panel_icon_->SetIsDrawable(true);

  // The container that any text in the bar will be added to.
  text_container_->SetIsDrawable(true);

  // Drag Handlebar
  drag_handlebar_->SetIsDrawable(true);

  // Open Tab Icon
  open_tab_icon_->SetIsDrawable(true);
  layer_->AddChild(open_tab_icon_);

  // Close Icon
  close_icon_->SetIsDrawable(true);
  layer_->AddChild(close_icon_);

  // Content Container
  content_container_->SetIsDrawable(true);
  layer_->AddChild(content_container_);

  // Bar Border
  bar_border_->SetIsDrawable(true);

  // Bar Shadow
  bar_shadow_->SetIsDrawable(true);

  // Progress Bar Background
  progress_bar_background_->SetIsDrawable(true);
  progress_bar_background_->SetFillCenter(true);

  // Progress Bar
  progress_bar_->SetIsDrawable(true);
  progress_bar_->SetFillCenter(true);
}

OverlayPanelLayer::~OverlayPanelLayer() = default;

scoped_refptr<cc::slim::Layer> OverlayPanelLayer::layer() {
  return layer_;
}

}  //  namespace android