// Copyright 2025 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/examples/test_app_window.h"

#include <memory>
#include <optional>

#include "ash/shell.h"
#include "ash/utility/client_controlled_state_util.h"
#include "ash/wm/window_pin_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chromeos/ui/base/app_types.h"
#include "chromeos/ui/base/window_properties.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/base/models/combobox_model.h"
#include "ui/color/color_variant.h"
#include "ui/gfx/geometry/size.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/background.h"
#include "ui/views/controls/button/checkbox.h"
#include "ui/views/controls/combobox/combobox.h"
#include "ui/views/controls/label.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/layout/box_layout.h"
#include "ui/views/view.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"

namespace ash {
namespace {

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

 private:
  // ui::ComboboxModel:
  size_t GetItemCount() const override {
    return static_cast<size_t>(chromeos::AppType::kMaxValue) + 1;
  }
  std::u16string GetItemAt(size_t index) const override {
    switch (static_cast<chromeos::AppType>(index)) {
      case chromeos::AppType::NON_APP:
        return u"AppType: None";
      case chromeos::AppType::BROWSER:
        return u"AppType: Browser";
      case chromeos::AppType::CHROME_APP:
        return u"AppType: ChromeApp";
      case chromeos::AppType::ARC_APP:
        return u"AppType: Arc";
      case chromeos::AppType::CROSTINI_APP:
        return u"AppType: Crostini";
      case chromeos::AppType::SYSTEM_APP:
        return u"AppType: SystemApp";
    }
    return u"AppType: Unknown";
  }
};

class TestView : public views::View {
 public:
  enum ViewElements : int {
    kAppTypesCombobox = 1000,
    kOpenClientControlledButton,
  };

  explicit TestView(bool add_open_client_controlled) {
    SetBackground(
        views::CreateSolidBackground(ui::ColorVariant(SK_ColorWHITE)));
    auto* layout = SetLayoutManager(std::make_unique<views::BoxLayout>(
        views::BoxLayout::Orientation::kVertical));
    layout->set_cross_axis_alignment(
        views::BoxLayout::CrossAxisAlignment::kStart);

    auto add_checkbox =
        [](views::View* container, const std::u16string& text,
           const std::u16string& tooltip, bool initial_state,
           base::RepeatingCallback<void(const ui::Event&)> callback) {
          views::Checkbox* checkbox = container->AddChildView(
              std::make_unique<views::Checkbox>(text, std::move(callback)));
          checkbox->SetChecked(initial_state);
          checkbox->SetTooltipText(tooltip);
          return checkbox;
        };
    auto add_textfield = [](views::View* container, const std::u16string& text,
                            const std::u16string& tooltip,
                            const std::u16string& initial_value) {
      views::View* hc =
          container->AddChildView(std::make_unique<views::View>());
      auto* layout = hc->SetLayoutManager(std::make_unique<views::BoxLayout>(
          views::BoxLayout::Orientation::kHorizontal));
      layout->set_cross_axis_alignment(
          views::BoxLayout::CrossAxisAlignment::kCenter);

      views::Label* label =
          hc->AddChildView(std::make_unique<views::Label>(text));
      label->SetTooltipText(tooltip);

      views::Textfield* textfield =
          hc->AddChildView(std::make_unique<views::Textfield>());
      textfield->SetText(initial_value);
      textfield->GetViewAccessibility().SetName(
          std::u16string(), ax::mojom::NameFrom::kAttributeExplicitlyEmpty);
      layout->SetFlexForView(textfield, 1);
      return textfield;
    };

    add_checkbox(
        this, u"Activatable", u"activatable",
        /*initial_state=*/true, base::BindRepeating([](const ui::Event& event) {
          views::Checkbox* cb = static_cast<views::Checkbox*>(event.target());
          cb->GetWidget()->widget_delegate()->SetCanActivate(cb->GetChecked());
        }));
    add_checkbox(
        this, u"Resizable", u"resizable",
        /*initial_state=*/true, base::BindRepeating([](const ui::Event& event) {
          views::Checkbox* cb = static_cast<views::Checkbox*>(event.target());
          cb->GetWidget()->widget_delegate()->SetCanResize(cb->GetChecked());
        }));
    add_checkbox(
        this, u"Maximizable", u"maximizable",
        /*initial_state=*/true, base::BindRepeating([](const ui::Event& event) {
          views::Checkbox* cb = static_cast<views::Checkbox*>(event.target());
          cb->GetWidget()->widget_delegate()->SetCanMaximize(cb->GetChecked());
        }));
    add_checkbox(this, u"Always On Top", u"always on top",
                 /*initial_state=*/false,
                 base::BindRepeating([](const ui::Event& event) {
                   views::Checkbox* cb =
                       static_cast<views::Checkbox*>(event.target());
                   auto* window = cb->GetWidget()->GetNativeWindow();
                   window->SetProperty(aura::client::kZOrderingKey,
                                       cb->GetChecked()
                                           ? ui::ZOrderLevel::kFloatingWindow
                                           : ui::ZOrderLevel::kNormal);
                 }));
    add_checkbox(this, u"Pinned After 5 seconds", u"pinned",
                 /*initial_state=*/false,
                 base::BindRepeating(
                     [](TestView* this_, const ui::Event& event) {
                       views::Checkbox* cb =
                           static_cast<views::Checkbox*>(event.target());
                       auto* window = cb->GetWidget()->GetNativeWindow();
                       bool pinned = cb->GetChecked();
                       this_->RunAfterFiveSeconds(base::BindRepeating(
                           [](aura::Window* window, bool pinned) {
                             if (pinned) {
                               PinWindow(window, /*trusted=*/false);
                             } else {
                               UnpinWindow(window);
                             }
                           },
                           base::Unretained(window), pinned));
                     },
                     base::Unretained(this)));
    add_checkbox(this, u"Trusted Pinned After 5 seconds", u"trusted pinned",
                 /*initial_state=*/false,
                 base::BindRepeating(
                     [](TestView* this_, const ui::Event& event) {
                       views::Checkbox* cb =
                           static_cast<views::Checkbox*>(event.target());
                       auto* window = cb->GetWidget()->GetNativeWindow();
                       bool pinned = cb->GetChecked();
                       this_->RunAfterFiveSeconds(base::BindRepeating(
                           [](aura::Window* window, bool pinned) {
                             if (pinned) {
                               PinWindow(window, /*trusted=*/true);
                             } else {
                               UnpinWindow(window);
                             }
                           },
                           base::Unretained(window), pinned));
                     },
                     base::Unretained(this)));

    AddChildView(std::make_unique<views::LabelButton>(
        base::BindRepeating(
            &TestView::RunAfterFiveSeconds, base::Unretained(this),
            base::BindRepeating(
                [](views::View* view) -> void { view->GetWidget()->Close(); },
                base::Unretained(this))),
        u"Close After 5 seconds"));

    AddChildView(std::make_unique<views::LabelButton>(
        base::BindRepeating(
            &TestView::RunAfterFiveSeconds, base::Unretained(this),
            base::BindRepeating(
                [](views::View* view) { view->GetWidget()->Activate(); },
                base::Unretained(this))),
        u"Activate After 5 seconds"));

    AddChildView(std::make_unique<views::LabelButton>(
        base::BindRepeating(
            &TestView::RunAfterFiveSeconds, base::Unretained(this),
            base::BindRepeating(
                [](views::View* view) { view->GetWidget()->Restore(); },
                base::Unretained(this))),
        u"Restore After 5 seconds"));

    AddChildView(std::make_unique<views::LabelButton>(
        base::BindRepeating(
            &TestView::RunAfterFiveSeconds, base::Unretained(this),
            base::BindRepeating(
                [](views::View* view) { view->GetWidget()->Minimize(); },
                base::Unretained(this))),
        u"Minimize After 5 seconds"));

    if (add_open_client_controlled) {
      AddChildView(
          std::make_unique<views::LabelButton>(
              base::BindRepeating(&OpenTestAppWindow,
                                  /*use_client_controlled_state=*/true),
              u"Open ClientControlled App Window"))
          ->SetID(kOpenClientControlledButton);
    }

    AddChildView(std::make_unique<views::LabelButton>(
        base::BindRepeating(&TestView::UpdateMinimumSize,
                            base::Unretained(this)),
        u"Apply Minimum Size"));

    width_ = add_textfield(this, u"Min Width", u"minimum width",
                           base::NumberToString16(GetMinimumSize().width()));
    height_ = add_textfield(this, u"Min height", u"minimum height",
                            base::NumberToString16(GetMinimumSize().height()));
    auto* app_types = AddChildView(std::make_unique<views::Combobox>(
        std::make_unique<AppTypeComboboxModel>()));
    app_types->GetViewAccessibility().SetName(
        std::u16string(), ax::mojom::NameFrom::kAttributeExplicitlyEmpty);
    app_types->SetCallback(base::BindRepeating(
        [](views::Combobox* app_types) -> void {
          size_t selected = app_types->GetSelectedIndex().value_or(0);
          auto* window = app_types->GetWidget()->GetNativeWindow();
          window->SetProperty(chromeos::kAppTypeKey,
                              static_cast<chromeos::AppType>(selected));
        },
        base::Unretained(app_types)));
    app_types->SetID(kAppTypesCombobox);
  }

  // views::View:
  gfx::Size GetMinimumSize() const override { return minimum_size_; }

  void AddedToWidget() override {
    // Initialize the app type values when the widget/window is ready.
    auto* app_types =
        static_cast<views::Combobox*>(GetViewByID(kAppTypesCombobox));
    if (GetViewByID(kOpenClientControlledButton)) {
      app_types->MenuSelectionAt(1);  // Browser
    } else {
      app_types->MenuSelectionAt(3);  // ARC
    }
  }

 private:
  void UpdateMinimumSize() {
    int width;
    int height;
    if (base::StringToInt(width_->GetText(), &width) &&
        base::StringToInt(height_->GetText(), &height)) {
      minimum_size_.SetSize(width, height);
      PreferredSizeChanged();
    } else {
      LOG(ERROR) << "Failed to set minimum size to:" << width_->GetText()
                 << " x " << height_->GetText();
    }
  }

  void RunAfterFiveSeconds(base::RepeatingCallback<void()> callback) {
    timer_.Start(FROM_HERE, base::Seconds(5), callback);
  }

  raw_ptr<views::Textfield> width_, height_;
  gfx::Size minimum_size_{250, 100};
  base::OneShotTimer timer_;
};

}  // namespace

void OpenTestAppWindow(bool use_client_controlled_state) {
  views::Widget* widget = new views::Widget;
  views::Widget::InitParams params(
      views::Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET,
      views::Widget::InitParams::TYPE_WINDOW);
  auto widget_delegate = std::make_unique<views::WidgetDelegate>();
  widget_delegate->SetCanActivate(true);
  widget_delegate->SetCanFullscreen(true);
  widget_delegate->SetCanMaximize(true);
  widget_delegate->SetCanMinimize(true);
  widget_delegate->SetCanResize(true);
  widget_delegate->SetTitle(use_client_controlled_state
                                ? u"TestAppWindow(ClientControlled)"
                                : u"TestAppWindow(Normal)");

  params.delegate = widget_delegate.release();
  params.delegate->SetContentsView(
      std::make_unique<TestView>(!use_client_controlled_state));

  params.context = Shell::GetPrimaryRootWindow();
  params.name = "AshTestAppWindow";
  widget->Init(std::move(params));

  if (use_client_controlled_state) {
    ClientControlledStateUtil::BuildAndSet(widget->GetNativeWindow());
  }

  widget->Show();
}

}  // namespace ash