// Copyright 2024 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/quick_insert/quick_insert_suggestions_controller.h"

#include "ash/clipboard/clipboard_history_item.h"
#include "ash/clipboard/test_support/clipboard_history_item_builder.h"
#include "ash/clipboard/test_support/mock_clipboard_history_controller.h"
#include "ash/quick_insert/mock_quick_insert_client.h"
#include "ash/quick_insert/model/quick_insert_model.h"
#include "ash/test/ash_test_base.h"
#include "base/files/scoped_temp_dir.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/mock_callback.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/test/test_future.h"
#include "components/history/core/browser/history_service.h"
#include "components/history/core/browser/history_types.h"
#include "components/history/core/test/history_service_test_util.h"
#include "ui/base/ime/ash/fake_ime_keyboard.h"
#include "ui/base/ime/fake_text_input_client.h"

namespace ash {
namespace {

using ::base::test::RunOnceCallback;
using ::testing::_;
using ::testing::AllOf;
using ::testing::AnyNumber;
using ::testing::Contains;
using ::testing::Each;
using ::testing::Field;
using ::testing::FieldsAre;
using ::testing::IsEmpty;
using ::testing::IsSupersetOf;
using ::testing::NiceMock;
using ::testing::Not;
using ::testing::Property;
using ::testing::Return;
using ::testing::VariantWith;
using ::testing::WithArg;

class QuickInsertSuggestionsControllerTest : public testing::Test {
 public:
  QuickInsertSuggestionsControllerTest() {
    CHECK(history_dir_.CreateUniqueTempDir());
    history_service_ =
        history::CreateHistoryService(history_dir_.GetPath(), true);
  }

  history::HistoryService* GetHistoryService() {
    return history_service_.get();
  }

 private:
  base::test::TaskEnvironment task_environment_;
  base::ScopedTempDir history_dir_;
  std::unique_ptr<history::HistoryService> history_service_;
};

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWhenUnfocusedReturnsNewWindowResults) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/nullptr,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(callback,
              Run(Contains(VariantWith<QuickInsertNewWindowResult>(_))))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWhenSelectedTextReturnsEditorRewriteResults) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetSuggestedEditorResults)
      .WillOnce(RunOnceCallback<0>(std::vector<QuickInsertSearchResult>{
          QuickInsertEditorResult(QuickInsertEditorResult::Mode::kRewrite, u"",
                                  {}, {}),
      }));
  QuickInsertSuggestionsController controller;
  ui::FakeTextInputClient input_field({.type = ui::TEXT_INPUT_TYPE_TEXT});
  input_field.SetTextAndSelection(u"a", gfx::Range(0, 1));
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/&input_field,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(callback,
              Run(AllOf(Not(IsEmpty()),
                        Each(VariantWith<QuickInsertEditorResult>(
                            Field(&QuickInsertEditorResult::mode,
                                  QuickInsertEditorResult::Mode::kRewrite))))))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWithSelectionReturnsLobsterResult) {
  NiceMock<MockQuickInsertClient> client;
  QuickInsertSuggestionsController controller;
  ui::FakeTextInputClient input_field({.type = ui::TEXT_INPUT_TYPE_TEXT});
  input_field.SetTextAndSelection(u"a", gfx::Range(0, 1));
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, &input_field, &keyboard,
                         QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(callback,
              Run(IsSupersetOf({
                  QuickInsertLobsterResult(
                      QuickInsertLobsterResult::Mode::kWithSelection, u""),
              })))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWhenFocusedDoesNotReturnNewWindowResults) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  ui::FakeTextInputClient input_field({.type = ui::TEXT_INPUT_TYPE_TEXT});
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/&input_field,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback,
              Run(Contains(VariantWith<QuickInsertNewWindowResult>(_))))
      .Times(0);
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWhenCapsOffReturnsCapsOn) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  input_method::FakeImeKeyboard keyboard;
  keyboard.SetCapsLockEnabled(false);
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/nullptr,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(
      callback,
      Run(Contains(QuickInsertCapsLockResult(
          /*enabled=*/true, QuickInsertCapsLockResult::Shortcut::kAltSearch))))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWhenCapsOnReturnsCapsOff) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  input_method::FakeImeKeyboard keyboard;
  keyboard.SetCapsLockEnabled(true);
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/nullptr,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(
      callback,
      Run(Contains(QuickInsertCapsLockResult(
          /*enabled=*/false, QuickInsertCapsLockResult::Shortcut::kAltSearch))))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWithSelectionReturnsCaseTransforms) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  ui::FakeTextInputClient input_field({.type = ui::TEXT_INPUT_TYPE_TEXT});
  input_field.SetTextAndSelection(u"a", gfx::Range(0, 1));
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, &input_field, &keyboard,
                         QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(callback,
              Run(IsSupersetOf({
                  QuickInsertCaseTransformResult(
                      QuickInsertCaseTransformResult::Type::kUpperCase),
                  QuickInsertCaseTransformResult(
                      QuickInsertCaseTransformResult::Type::kLowerCase),
                  QuickInsertCaseTransformResult(
                      QuickInsertCaseTransformResult::Type::kTitleCase),
              })))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsWithNoSelectionDoesNotReturnCaseTransforms) {
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(GetHistoryService()));
  QuickInsertSuggestionsController controller;
  ui::FakeTextInputClient input_field({.type = ui::TEXT_INPUT_TYPE_TEXT});
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, &input_field, &keyboard,
                         QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run(_)).Times(AnyNumber());
  EXPECT_CALL(callback, Run(Contains(QuickInsertCaseTransformResult(
                            QuickInsertCaseTransformResult::Type::kUpperCase))))
      .Times(0);
  EXPECT_CALL(callback, Run(Contains(QuickInsertCaseTransformResult(
                            QuickInsertCaseTransformResult::Type::kLowerCase))))
      .Times(0);
  EXPECT_CALL(callback, Run(Contains(QuickInsertCaseTransformResult(
                            QuickInsertCaseTransformResult::Type::kTitleCase))))
      .Times(0);

  controller.GetSuggestions(client, model, callback.Get());
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsRequestsAndReturnsSuggestionsPerCategory) {
  const base::Time now = base::Time::Now();
  auto* history_service = GetHistoryService();
  history_service->AddPageWithDetails(
      GURL("https://a.com"), /*title=*/u"", /*visit_count=*/1,
      /*typed_count=*/1,
      /*last_visit=*/now,
      /*hidden=*/false, history::SOURCE_BROWSED);
  history_service->AddPageWithDetails(
      GURL("https://b.com"), /*title=*/u"", /*visit_count=*/1,
      /*typed_count=*/1,
      /*last_visit=*/now - base::Seconds(1),
      /*hidden=*/false, history::SOURCE_BROWSED);
  history::BlockUntilHistoryProcessesPendingRequests(history_service);
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(history_service));
  EXPECT_CALL(client, GetRecentDriveFileResults(5, _))
      .WillOnce(RunOnceCallback<1>(std::vector<QuickInsertSearchResult>{
          QuickInsertDriveFileResult(/*id=*/{}, u"a", GURL("a.com"),
                                     /*file_path=*/{}),
          QuickInsertDriveFileResult(/*id=*/{}, u"b", GURL("b.com"),
                                     /*file_path=*/{}),
      }));
  EXPECT_CALL(client, GetRecentLocalFileResults(3, _, _))
      .WillOnce(RunOnceCallback<2>(std::vector<QuickInsertSearchResult>{
          QuickInsertLocalFileResult(u"a", /*file_path=*/{}),
          QuickInsertLocalFileResult(u"b", /*file_path=*/{}),
          QuickInsertLocalFileResult(u"c", /*file_path=*/{}),
          QuickInsertLocalFileResult(u"d", /*file_path=*/{}),
      }));
  QuickInsertSuggestionsController controller;
  input_method::FakeImeKeyboard keyboard;
  QuickInsertModel model(/*prefs=*/nullptr, /*focused_client=*/nullptr,
                         &keyboard, QuickInsertModel::EditorStatus::kEnabled,
                         QuickInsertModel::LobsterStatus::kEnabled);

  base::test::TestFuture<void> history_future;
  base::MockCallback<QuickInsertSuggestionsController::SuggestionsCallback>
      callback;
  EXPECT_CALL(callback, Run).Times(AnyNumber());
  EXPECT_CALL(
      callback,
      Run(ElementsAre(VariantWith<QuickInsertBrowsingHistoryResult>(_))))
      .WillOnce([&]() { history_future.SetValue(); });
  EXPECT_CALL(callback,
              Run(ElementsAre(VariantWith<QuickInsertDriveFileResult>(_))))
      .Times(1);
  EXPECT_CALL(callback,
              Run(ElementsAre(VariantWith<QuickInsertLocalFileResult>(_),
                              VariantWith<QuickInsertLocalFileResult>(_),
                              VariantWith<QuickInsertLocalFileResult>(_))))
      .Times(1);

  controller.GetSuggestions(client, model, callback.Get());
  ASSERT_TRUE(history_future.Wait());
}

TEST_F(QuickInsertSuggestionsControllerTest, GetSuggestionsForLinkCategory) {
  const base::Time now = base::Time::Now();
  auto* history_service = GetHistoryService();
  history_service->AddPageWithDetails(
      GURL("https://a.com"), /*title=*/u"a", /*visit_count=*/1,
      /*typed_count=*/1,
      /*last_visit=*/now,
      /*hidden=*/false, history::SOURCE_BROWSED);
  history_service->AddPageWithDetails(
      GURL("https://b.com"), /*title=*/u"b", /*visit_count=*/1,
      /*typed_count=*/1,
      /*last_visit=*/now - base::Seconds(1),
      /*hidden=*/false, history::SOURCE_BROWSED);
  history::BlockUntilHistoryProcessesPendingRequests(history_service);
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetHistoryService)
      .WillRepeatedly(Return(history_service));
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kLinks,
                                       future.GetRepeatingCallback());

  EXPECT_THAT(future.Take(),
              ElementsAre(VariantWith<QuickInsertBrowsingHistoryResult>(
                              FieldsAre(GURL("https://a.com"), u"a", _, _)),
                          VariantWith<QuickInsertBrowsingHistoryResult>(
                              FieldsAre(GURL("https://b.com"), u"b", _, _))));
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsForDriveFileCategory) {
  const std::vector<QuickInsertSearchResult> suggested_files = {
      QuickInsertDriveFileResult(/*id=*/{}, u"a", GURL("a.com"),
                                 /*file_path=*/{}),
      QuickInsertDriveFileResult(/*id=*/{}, u"b", GURL("b.com"),
                                 /*file_path=*/{}),
  };
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetRecentDriveFileResults)
      .WillOnce(RunOnceCallback<1>(suggested_files));
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kDriveFiles,
                                       future.GetRepeatingCallback());

  EXPECT_EQ(future.Take(), suggested_files);
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsForLocalFileCategory) {
  const std::vector<QuickInsertSearchResult> suggested_files = {
      QuickInsertLocalFileResult(u"a", /*file_path=*/{}),
      QuickInsertLocalFileResult(u"b", /*file_path=*/{}),
  };
  NiceMock<MockQuickInsertClient> client;
  EXPECT_CALL(client, GetRecentLocalFileResults)
      .WillOnce(RunOnceCallback<2>(suggested_files));
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kLocalFiles,
                                       future.GetRepeatingCallback());

  EXPECT_EQ(future.Take(), suggested_files);
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsForDatesCategoryReturnsSomeResults) {
  NiceMock<MockQuickInsertClient> client;
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kDatesTimes,
                                       future.GetRepeatingCallback());

  EXPECT_THAT(future.Take(), Not(IsEmpty()));
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsForMathsCategoryReturnsSomeResults) {
  NiceMock<MockQuickInsertClient> client;
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kUnitsMaths,
                                       future.GetRepeatingCallback());

  EXPECT_THAT(future.Take(), Not(IsEmpty()));
}

TEST_F(QuickInsertSuggestionsControllerTest,
       GetSuggestionsForClipboardCategory) {
  ClipboardHistoryItem clipboard_item =
      ClipboardHistoryItemBuilder()
          .SetFormat(ui::ClipboardInternalFormat::kText)
          .SetText("abc")
          .Build();
  MockClipboardHistoryController mock_clipboard;
  EXPECT_CALL(mock_clipboard, GetHistoryValues)
      .WillOnce(RunOnceCallback<0>(
          std::vector<ClipboardHistoryItem>{clipboard_item}));
  NiceMock<MockQuickInsertClient> client;
  QuickInsertSuggestionsController controller;

  base::test::TestFuture<std::vector<QuickInsertSearchResult>> future;
  controller.GetSuggestionsForCategory(client, QuickInsertCategory::kClipboard,
                                       future.GetRepeatingCallback());

  EXPECT_THAT(future.Take(),
              ElementsAre(VariantWith<QuickInsertClipboardResult>(
                  FieldsAre(_, QuickInsertClipboardResult::DisplayFormat::kText,
                            _, u"abc", _, _))));
}

}  // namespace
}  // namespace ash