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

#include "ui/views/examples/actions_example.h"

#include <algorithm>
#include <memory>
#include <optional>
#include <string_view>
#include <utility>

#include "base/callback_list.h"
#include "base/containers/fixed_flat_map.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/scoped_observation.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "ui/actions/action_id.h"
#include "ui/actions/actions.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/metadata/metadata_header_macros.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/models/combobox_model.h"
#include "ui/color/color_id.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/actions/action_view_controller.h"
#include "ui/views/border.h"
#include "ui/views/controls/button/checkbox.h"
#include "ui/views/controls/button/md_text_button.h"
#include "ui/views/controls/combobox/combobox.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/separator.h"
#include "ui/views/controls/textarea/textarea.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/examples/example_combobox_model.h"
#include "ui/views/examples/examples_action_id.h"
#include "ui/views/examples/grit/views_examples_resources.h"
#include "ui/views/layout/box_layout_view.h"
#include "ui/views/layout/layout_manager_base.h"
#include "ui/views/layout/proposed_layout.h"
#include "ui/views/metadata/view_factory.h"
#include "ui/views/style/typography.h"
#include "ui/views/view.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/view_observer.h"
#include "ui/views/view_utils.h"

namespace views::examples {

namespace {

constexpr int kActionExampleVerticalSpacing = 3;
constexpr int kActionExampleLeftPadding = 8;
constexpr gfx::Insets kSeparatorPadding = gfx::Insets::TLBR(5, 0, 5, 0);
const char* kBoolStrings[2] = {"false", "true"};

#define MAP_ACTION_IDS_TO_STRINGS
#include "ui/actions/action_id_macros.inc"

// clang-format off
constexpr auto kActionIdStrings =
    base::MakeFixedFlatMap<actions::ActionId, const char*>({
        ACTION_IDS
        EXAMPLES_ACTION_IDS
    });
// clang-format on

#include "ui/actions/action_id_macros.inc"  // NOLINT(build/include)
#undef STRINGIZE_ACTION_IDS

class ViewsComboboxModel : public ui::ComboboxModel, public ViewObserver {
 public:
  explicit ViewsComboboxModel(View* container);
  ViewsComboboxModel(const ViewsComboboxModel&) = delete;
  ViewsComboboxModel& operator=(const ViewsComboboxModel&) = delete;
  ~ViewsComboboxModel() override = default;

  // ui::ComboboxModel overrides.
  size_t GetItemCount() const override;
  std::u16string GetItemAt(size_t index) const override;
  std::optional<size_t> GetDefaultIndex() const override;

  View* GetViewItemAt(size_t index) const;

 protected:
  // ViewObserver overrides
  void OnViewIsDeleting(View* observed_view) override;

 private:
  raw_ptr<View> container_;
  base::ScopedObservation<View, ViewObserver> container_observation_{this};
};

ViewsComboboxModel::ViewsComboboxModel(View* container)
    : container_(container) {
  container_observation_.Observe(container_);
}

size_t ViewsComboboxModel::GetItemCount() const {
  size_t size = container_->children().size();
  return size ? size : 1;
}

std::u16string ViewsComboboxModel::GetItemAt(size_t index) const {
  if (container_->children().size()) {
    View* view = container_->children()[index];
    if (IsViewClass<MdTextButton>(view)) {
      std::stringstream ss;
      ss << index;
      return base::ASCIIToUTF16(std::string_view("Button: " + ss.str()));
    }
    if (IsViewClass<Checkbox>(view)) {
      std::stringstream ss;
      ss << index;
      return base::ASCIIToUTF16(std::string_view("Checkbox: " + ss.str()));
    }
  }
  return u"<Unknown>";
}

std::optional<size_t> ViewsComboboxModel::GetDefaultIndex() const {
  return {0};
}

View* ViewsComboboxModel::GetViewItemAt(size_t index) const {
  if (container_->children().size()) {
    return container_->children()[index];
  }
  return nullptr;
}

void ViewsComboboxModel::OnViewIsDeleting(View* observed_view) {
  if (observed_view == container_.get()) {
    container_observation_.Reset();
    container_ = nullptr;
  }
}

class ActionItemComboboxModel : public ui::ComboboxModel {
 public:
  explicit ActionItemComboboxModel(actions::ActionItem* action_scope);
  ActionItemComboboxModel(const ActionItemComboboxModel&) = delete;
  ActionItemComboboxModel& operator=(const ActionItemComboboxModel&) = delete;
  ~ActionItemComboboxModel() override = default;

  // ui::ComboboxModel overrides.
  size_t GetItemCount() const override;
  std::u16string GetItemAt(size_t index) const override;

  actions::ActionItem* GetActionItemAt(size_t index) const;

 private:
  actions::ActionItemVector items_;
};

ActionItemComboboxModel::ActionItemComboboxModel(
    actions::ActionItem* action_scope) {
  actions::ActionManager::Get().GetActions(items_, action_scope);
}

size_t ActionItemComboboxModel::GetItemCount() const {
  return items_.size();
}

std::u16string ActionItemComboboxModel::GetItemAt(size_t index) const {
  return std::u16string(GetActionItemAt(index)->GetText());
}

actions::ActionItem* ActionItemComboboxModel::GetActionItemAt(
    size_t index) const {
  return items_[index];
}

class ControlTypeComboboxModel : public ui::ComboboxModel {
 public:
  ControlTypeComboboxModel() = default;
  ControlTypeComboboxModel(const ControlTypeComboboxModel&) = delete;
  ControlTypeComboboxModel& operator=(const ControlTypeComboboxModel&) = delete;
  ~ControlTypeComboboxModel() override = default;

  // ui::ComboboxModel overrides.
  size_t GetItemCount() const override;
  std::u16string GetItemAt(size_t index) const override;
};

size_t ControlTypeComboboxModel::GetItemCount() const {
  return 2;
}

std::u16string ControlTypeComboboxModel::GetItemAt(size_t index) const {
  switch (index) {
    case 0:
      return u"Button";
    case 1:
      return u"Checkbox";
    default:
      NOTREACHED();
  }
}

class FlowLayout : public LayoutManagerBase {
 public:
  FlowLayout() = default;
  FlowLayout(const FlowLayout&) = delete;
  FlowLayout& operator=(const FlowLayout&) = delete;
  ~FlowLayout() override = default;

 protected:
  ProposedLayout CalculateProposedLayout(
      const SizeBounds& size_bounds) const override;
};

ProposedLayout FlowLayout::CalculateProposedLayout(
    const SizeBounds& size_bounds) const {
  ProposedLayout layout;
  int x = 0;
  int y = 0;
  int max_height = 0;
  for (views::View* view : host_view()->children()) {
    bool view_visible = view->GetVisible();
    gfx::Size preferred_size = view->GetPreferredSize(size_bounds);
    if (view_visible) {
      max_height = std::max(max_height, preferred_size.height());
      if (x > 0 && (x + preferred_size.width() > size_bounds.width())) {
        x = 0;
        y += max_height;
        max_height = 0;
      }
    }
    gfx::Rect proposed_bounds = gfx::Rect(gfx::Point(x, y), preferred_size);
    SizeBounds available_bounds = SizeBounds(preferred_size);
    ChildLayout child_layout = {view, view_visible, proposed_bounds,
                                available_bounds};
    layout.child_layouts.push_back(child_layout);
    if (view_visible) {
      x += preferred_size.width();
    }
  }
  return layout;
}

}  // namespace

ActionsExample::ActionsExample() : ExampleBase("Actions") {
  subscriptions_.push_back(
      actions::ActionManager::Get().AppendActionItemInitializer(
          base::BindRepeating(&ActionsExample::CreateActions,
                              base::Unretained(this))));
}

ActionsExample::~ActionsExample() = default;

void ActionsExample::CreateExampleView(View* container) {
  Builder<View>(container)
      .SetUseDefaultFillLayout(true)
      .AddChild(
          Builder<BoxLayoutView>()
              .SetOrientation(BoxLayout::Orientation::kHorizontal)
              .AddChildren(
                  Builder<View>()
                      .CopyAddressTo(&action_panel_)
                      .SetLayoutManager(std::make_unique<FlowLayout>())
                      .SetBorder(CreateSolidBorder(
                          1, ui::kColorFocusableBorderUnfocused)),
                  Builder<BoxLayoutView>()
                      .CopyAddressTo(&control_panel_)
                      .SetOrientation(BoxLayout::Orientation::kVertical)
                      .SetInsideBorderInsets(
                          gfx::Insets::VH(kActionExampleVerticalSpacing,
                                          kActionExampleLeftPadding))
                      .SetBetweenChildSpacing(kActionExampleVerticalSpacing))
              .AfterBuild(base::BindOnce(
                  [](raw_ptr<View>* action_panel,
                     raw_ptr<BoxLayoutView>* control_panel,
                     BoxLayoutView* box) {
                    box->SetFlexForView((*action_panel).get(), 4);
                    box->SetFlexForView((*control_panel).get(), 1);
                  },
                  &action_panel_, &control_panel_)))
      .BuildChildren();

  auto add_row = [this]() {
    auto* row = control_panel_->AddChildView(
        Builder<BoxLayoutView>()
            .SetOrientation(BoxLayout::Orientation::kHorizontal)
            .SetBetweenChildSpacing(kActionExampleVerticalSpacing)
            .SetCrossAxisAlignment(BoxLayout::CrossAxisAlignment::kCenter)
            .Build());
    return row;
  };

  auto add_combobox_row = [&add_row](
                              std::unique_ptr<ui::ComboboxModel> model,
                              int label_text) -> std::pair<View*, Combobox*> {
    auto* row = add_row();
    Label* label = nullptr;
    Combobox* combobox = nullptr;
    Builder<BoxLayoutView>(row)
        .AddChildren(
            Builder<Label>().CopyAddressTo(&label).SetText(
                l10n_util::GetStringUTF16(label_text)),
            Builder<Combobox>(std::make_unique<Combobox>(std::move(model)))
                .CopyAddressTo(&combobox))
        .BuildChildren();
    combobox->GetViewAccessibility().SetName(std::u16string(label->GetText()));
    return {row, combobox};
  };

  auto add_combobox_and_button = [&add_combobox_row, this](
                                     std::unique_ptr<ui::ComboboxModel> model,
                                     int label_text,
                                     actions::ActionId action_id) {
    auto pair = add_combobox_row(std::move(model), label_text);
    views::MdTextButton* action_button;
    pair.first->AddChildView(
        Builder<MdTextButton>().CopyAddressTo(&action_button).Build());
    action_view_controller_.CreateActionViewRelationship(
        action_button,
        actions::ActionManager::Get().FindAction(action_id)->GetAsWeakPtr());
    return pair.second;
  };

  auto add_checkbox_row = [this, &add_row](int checkbox_text,
                                           PropertyChangedCallback callback) {
    auto* row = add_row();
    auto* checkbox =
        row->AddChildView(Builder<Checkbox>()
                              .SetText(l10n_util::GetStringUTF16(checkbox_text))
                              .Build());
    subscriptions_.push_back(
        checkbox->AddCheckedChangedCallback(std::move(callback)));
    return checkbox;
  };

  auto add_textfield_row = [this, &add_row](int label_text,
                                            PropertyChangedCallback callback) {
    auto* row = add_row();
    Label* label = nullptr;
    Textfield* textfield = nullptr;
    Builder<BoxLayoutView>(row)
        .AddChildren(
            Builder<Label>().CopyAddressTo(&label).SetText(
                l10n_util::GetStringUTF16(label_text)),
            Builder<Textfield>()
                .CopyAddressTo(&textfield)
                .CustomConfigure(base::BindOnce(
                    [](std::vector<base::CallbackListSubscription>*
                           subscriptions,
                       PropertyChangedCallback callback, Textfield* textfield) {
                      subscriptions->push_back(
                          textfield->AddTextChangedCallback(
                              std::move(callback)));
                    },
                    &subscriptions_, std::move(callback))))
        .AfterBuild(base::BindOnce(
            [](Textfield** textfield, Label** label, BoxLayoutView* row) {
              row->SetFlexForView(*textfield, 1);
              (*textfield)
                  ->GetViewAccessibility()
                  .SetName(std::u16string((*label)->GetText()));
            },
            &textfield, &label))
        .BuildChildren();
    return textfield;
  };

  available_controls_ =
      add_combobox_and_button(std::make_unique<ControlTypeComboboxModel>(),
                              IDS_AVAILABLE_CONTROLS, kActionCreateControl);

  control_panel_->AddChildView(
      Builder<Separator>().SetProperty(kMarginsKey, kSeparatorPadding).Build());

  controls_ = add_combobox_row(
                  std::make_unique<ViewsComboboxModel>(action_panel_.get()),
                  IDS_CONTROLS)
                  .second;

  available_actions_ = add_combobox_and_button(
      std::make_unique<ActionItemComboboxModel>(example_actions_.get()),
      IDS_AVAILABLE_ACTIONS, kActionAssignAction);
  subscriptions_.push_back(
      available_actions_->AddSelectedIndexChangedCallback(base::BindRepeating(
          &ActionsExample::ActionSelected, base::Unretained(this))));

  action_visible_ = add_checkbox_row(
      IDS_ACTION_VISIBLE, base::BindRepeating(&ActionsExample::VisibleChanged,
                                              base::Unretained(this)));
  action_enabled_ = add_checkbox_row(
      IDS_ACTION_ENABLED, base::BindRepeating(&ActionsExample::EnabledChanged,
                                              base::Unretained(this)));
  action_checked_ = add_checkbox_row(
      IDS_ACTION_CHECKED, base::BindRepeating(&ActionsExample::CheckedChanged,
                                              base::Unretained(this)));
  action_text_ = add_textfield_row(
      IDS_ACTION_TEXT, base::BindRepeating(&ActionsExample::TextChanged,
                                           base::Unretained(this)));
  action_tooltip_text_ =
      add_textfield_row(IDS_ACTION_TOOLTIP_TEXT,
                        base::BindRepeating(&ActionsExample::TooltipTextChanged,
                                            base::Unretained(this)));
  auto* row = add_row();
  control_panel_->SetFlexForView(row, 1);
  actions_trigger_info_ =
      row->AddChildView(Builder<Textarea>()
                            .SetReadOnly(true)
                            .SetAccessibleName(l10n_util::GetStringUTF16(
                                IDS_ACTIONS_TRIGGER_INFO))
                            .Build());
  row->SetCrossAxisAlignment(BoxLayout::CrossAxisAlignment::kStretch);
  row->SetFlexForView(actions_trigger_info_.get(), 1);

  ActionSelected();
}

void ActionsExample::CreateActions(actions::ActionManager* manager) {
  manager->AddActions(
      actions::ActionItem::Builder()
          .CopyAddressTo(&example_actions_)
          .AddChildren(actions::ActionItem::Builder(
                           base::BindRepeating(&ActionsExample::ActionInvoked,
                                               base::Unretained(this)))
                           .SetText(u"Test Action 1")
                           .SetActionId(kActionTest1),
                       actions::ActionItem::Builder(
                           base::BindRepeating(&ActionsExample::ActionInvoked,
                                               base::Unretained(this)))
                           .SetText(u"Test Action 2")
                           .SetActionId(kActionTest2),
                       actions::ActionItem::Builder(
                           base::BindRepeating(&ActionsExample::ActionInvoked,
                                               base::Unretained(this)))
                           .SetText(u"Test Action 3")
                           .SetActionId(kActionTest2))
          .Build(),
      actions::ActionItem::Builder()
          .AddChildren(
              actions::ActionItem::Builder(
                  base::BindRepeating(&ActionsExample::AssignAction,
                                      base::Unretained(this)))
                  .SetActionId(kActionAssignAction)
                  .SetText(
                      l10n_util::GetStringUTF16(IDS_ASSIGN_ACTION_TO_CONTROL)),
              actions::ActionItem::Builder(
                  base::BindRepeating(&ActionsExample::CreateControl,
                                      base::Unretained(this)))
                  .SetActionId(kActionCreateControl)
                  .SetText(l10n_util::GetStringUTF16(IDS_CREATE_CONTROL)))
          .Build());
}

void ActionsExample::ActionInvoked(actions::ActionItem* action,
                                   actions::ActionInvocationContext context) {
  auto bool_to_string = [](bool value) {
    return value ? kBoolStrings[1] : kBoolStrings[0];
  };
  std::u16string text(actions_trigger_info_->GetText());
  if (!text.empty()) {
    text.append(u"\n");
  }
  text.append(base::ASCIIToUTF16(base::StringPrintf(
      "Action ID: %s; Text: \"%s\"; Visible: %s; Enabled: %s",
      kActionIdStrings.at(
          action->GetActionId().value_or(actions::kActionsStart)),
      base::UTF16ToASCII(action->GetText()).c_str(),
      bool_to_string(action->GetVisible()),
      bool_to_string(action->GetEnabled()))));
  // Manually append the text since Textfield::AppendText() is broken right now.
  // (crbug.com/1476989)
  actions_trigger_info_->SetText(text);
  if (GetSelectedAction() == action) {
    action_checked_->SetChecked(action->GetChecked());
  }
}

void ActionsExample::ActionSelected() {
  const actions::ActionItem* action_item = GetSelectedAction();
  action_checked_->SetChecked(action_item->GetChecked());
  action_visible_->SetChecked(action_item->GetVisible());
  action_enabled_->SetChecked(action_item->GetEnabled());
  action_text_->SetText(action_item->GetText());
  action_tooltip_text_->SetText(action_item->GetTooltipText());
}

void ActionsExample::AssignAction(actions::ActionItem* action,
                                  actions::ActionInvocationContext context) {
  auto index = controls_->GetSelectedIndex();
  if (!index || controls_->GetModel()->GetItemCount() == 0) {
    return;
  }
  ViewsComboboxModel* model =
      static_cast<ViewsComboboxModel*>(controls_->GetModel());
  size_t index_val = index.value();
  View* view = model->GetViewItemAt(index_val);
  if (IsViewClass<MdTextButton>(view)) {
    action_view_controller_.CreateActionViewRelationship(
        static_cast<MdTextButton*>(view), GetSelectedAction()->GetAsWeakPtr());
  } else if (IsViewClass<Checkbox>(view)) {
    action_view_controller_.CreateActionViewRelationship(
        static_cast<Checkbox*>(view), GetSelectedAction()->GetAsWeakPtr());
  }
}

void ActionsExample::CreateControl(actions::ActionItem* action,
                                   actions::ActionInvocationContext context) {
  static int control_num = 0;
  std::unique_ptr<View> new_view;
  const std::optional<size_t> selected_index =
      available_controls_->GetSelectedIndex();
  switch (selected_index.value_or(0)) {
    case 0:
      new_view = Builder<MdTextButton>()
                     .SetText(u"Button " + base::NumberToString16(control_num))
                     .Build();
      break;
    case 1:
      new_view =
          Builder<Checkbox>()
              .SetText(u"Checkbox " + base::NumberToString16(control_num))
              .Build();
      break;
    default:
      NOTREACHED();
  }
  action_panel_->AddChildView(std::move(new_view));
  ++control_num;
}

actions::ActionItem* ActionsExample::GetSelectedAction() const {
  ActionItemComboboxModel* action_item_model =
      static_cast<ActionItemComboboxModel*>(available_actions_->GetModel());
  return action_item_model->GetActionItemAt(
      available_actions_->GetSelectedIndex().value_or(0));
}

void ActionsExample::EnabledChanged() {
  actions::ActionItem* action = GetSelectedAction();
  action->SetEnabled(action_enabled_->GetChecked());
}

void ActionsExample::CheckedChanged() {
  actions::ActionItem* action = GetSelectedAction();
  action->SetChecked(action_checked_->GetChecked());
}

void ActionsExample::TextChanged() {
  actions::ActionItem* action = GetSelectedAction();
  action->SetText(action_text_->GetText());
}

void ActionsExample::TooltipTextChanged() {
  actions::ActionItem* action = GetSelectedAction();
  action->SetTooltipText(action_tooltip_text_->GetText());
}

void ActionsExample::VisibleChanged() {
  actions::ActionItem* action = GetSelectedAction();
  action->SetVisible(action_visible_->GetChecked());
}

}  // namespace views::examples