// Copyright 2013 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/ash/file_manager/file_tasks.h"

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

#include "ash/constants/ash_features.h"
#include "ash/constants/web_app_id_constants.h"
#include "base/command_line.h"
#include "base/containers/to_vector.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/strings/escape.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/test/metrics/user_action_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/values.h"
#include "chrome/browser/apps/app_service/app_service_proxy_ash.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/app_service_test.h"
#include "chrome/browser/apps/app_service/policy_util.h"
#include "chrome/browser/ash/crostini/crostini_pref_names.h"
#include "chrome/browser/ash/crostini/crostini_test_helper.h"
#include "chrome/browser/ash/crostini/fake_crostini_features.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/file_manager/app_service_file_tasks.h"
#include "chrome/browser/ash/file_manager/file_manager_test_util.h"
#include "chrome/browser/ash/file_manager/office_file_tasks.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/virtual_file_tasks.h"
#include "chrome/browser/ash/file_manager/virtual_tasks/fake_virtual_task.h"
#include "chrome/browser/ash/file_manager/virtual_tasks/id_constants.h"
#include "chrome/browser/ash/guest_os/guest_os_mime_types_service.h"
#include "chrome/browser/ash/guest_os/guest_os_mime_types_service_factory.h"
#include "chrome/browser/ash/settings/scoped_cros_settings_test_helper.h"
#include "chrome/browser/chromeos/policy/dlp/dlp_rules_manager_factory.h"
#include "chrome/browser/chromeos/policy/dlp/test/mock_dlp_rules_manager.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/extensions/test_extension_system.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/web_applications/test/web_app_browsertest_util.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/testing_profile.h"
#include "chromeos/ash/components/dbus/concierge/concierge_client.h"
#include "chromeos/ash/components/file_manager/app_id.h"
#include "chromeos/constants/chromeos_features.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/testing_pref_service.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/services/app_service/public/cpp/features.h"
#include "components/services/app_service/public/cpp/file_handler.h"
#include "components/services/app_service/public/cpp/file_handler_info.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "content/public/common/content_features.h"
#include "content/public/test/browser_task_environment.h"
#include "extensions/browser/entry_info.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_system.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/manifest.h"
#include "google_apis/drive/drive_api_parser.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"

namespace file_manager::file_tasks {

TEST(FileManagerFileTasksTest, FullTaskDescriptor_WithIconAndDefault) {
  FullTaskDescriptor full_descriptor(
      TaskDescriptor("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"),
      "task title", GURL("http://example.com/icon.png"), true /* is_default */,
      false /* is_generic_file_handler */, false /* is_file_extension_match */);

  EXPECT_EQ("app-id", full_descriptor.task_descriptor.app_id);
  EXPECT_EQ(TaskType::TASK_TYPE_FILE_BROWSER_HANDLER,
            full_descriptor.task_descriptor.task_type);
  EXPECT_EQ("action-id", full_descriptor.task_descriptor.action_id);
  EXPECT_EQ("http://example.com/icon.png", full_descriptor.icon_url.spec());
  EXPECT_EQ("task title", full_descriptor.task_title);
  EXPECT_TRUE(full_descriptor.is_default);
}

TEST(FileManagerFileTasksTest, MakeTaskID) {
  EXPECT_EQ("app-id|file|action-id",
            MakeTaskID("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
  EXPECT_EQ("app-id|app|action-id",
            MakeTaskID("app-id", TASK_TYPE_FILE_HANDLER, "action-id"));
}

TEST(FileManagerFileTasksTest, TaskDescriptorToId) {
  EXPECT_EQ("app-id|file|action-id",
            TaskDescriptorToId(TaskDescriptor(
                "app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id")));
}

TEST(FileManagerFileTasksTest, ParseTaskID_FileBrowserHandler) {
  EXPECT_EQ(
      ParseTaskID("app-id|file|action-id"),
      TaskDescriptor("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
}

TEST(FileManagerFileTasksTest, ParseTaskID_FileHandler) {
  EXPECT_EQ(ParseTaskID("app-id|app|action-id"),
            TaskDescriptor("app-id", TASK_TYPE_FILE_HANDLER, "action-id"));
}

TEST(FileManagerFileTasksTest, ParseTaskID_Legacy) {
  // A legacy task ID only has two parts. The task type should be
  // TASK_TYPE_FILE_BROWSER_HANDLER.
  EXPECT_EQ(
      ParseTaskID("app-id|action-id"),
      TaskDescriptor("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
}

TEST(FileManagerFileTasksTest, ParseTaskID_Invalid) {
  EXPECT_FALSE(ParseTaskID("invalid"));
}

TEST(FileManagerFileTasksTest, ParseTaskID_UnknownTaskType) {
  EXPECT_FALSE(ParseTaskID("app-id|unknown|action-id"));
}

TEST(FileManagerFileTasksTest, BaseContainsFindsTaskDescriptors) {
  // Create several task descriptors that each have one field with the
  // "smallest" value in that category. i.e. task_1 has the "smallest" app_id
  // value, task_2 has the "smallest" task type value, and task_3 has the
  // "smallest" action_id value.
  TaskDescriptor task_1("a", TASK_TYPE_ARC_APP, "other");
  TaskDescriptor task_2("b", TASK_TYPE_FILE_BROWSER_HANDLER, "view");
  TaskDescriptor task_3("c", TASK_TYPE_FILE_HANDLER, "edit");

  std::set<TaskDescriptor> tasks;
  tasks.insert(task_1);
  tasks.insert(task_2);
  tasks.insert(task_3);

  ASSERT_TRUE(base::Contains(tasks, task_1));
  ASSERT_TRUE(base::Contains(tasks, task_2));
  ASSERT_TRUE(base::Contains(tasks, task_3));
}

TEST(FileManagerFileTasksTest, EqualTaskDescriptors) {
  TaskDescriptor task_1("a", TASK_TYPE_FILE_HANDLER, "view");
  TaskDescriptor task_2("a", TASK_TYPE_FILE_HANDLER, "view");

  ASSERT_EQ(task_1, task_2);
}

TEST(FileManagerFileTasksTest, NotEqualAppIdInTaskDescriptors) {
  TaskDescriptor task_1("a", TASK_TYPE_FILE_HANDLER, "view");
  TaskDescriptor task_2("b", TASK_TYPE_FILE_HANDLER, "view");

  ASSERT_NE(task_1, task_2);
}

TEST(FileManagerFileTasksTest, NotEqualTaskTypeInTaskDescriptors) {
  TaskDescriptor task_1("a", TASK_TYPE_FILE_HANDLER, "view");
  TaskDescriptor task_2("a", TASK_TYPE_FILE_BROWSER_HANDLER, "view");

  ASSERT_NE(task_1, task_2);
}

TEST(FileManagerFileTasksTest, NotEqualActionIdInTaskDescriptors) {
  TaskDescriptor task_1("a", TASK_TYPE_FILE_HANDLER, "view");
  TaskDescriptor task_2("a", TASK_TYPE_FILE_HANDLER, "edit");

  ASSERT_NE(task_1, task_2);
}

// Test FileHandlerIsEnabled which returns whether a file handler should be
// used.
TEST(FileManagerFileTasksTest, FileHandlerIsEnabled) {
  content::BrowserTaskEnvironment task_environment;
  TestingProfile test_profile;
  crostini::FakeCrostiniFeatures crostini_features;

  const std::string test_id = "test";

  crostini_features.set_export_import_ui_allowed(true);
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId,
                           "chrome://file-manager/?import-crostini-image"));
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId, test_id));

  crostini_features.set_export_import_ui_allowed(false);
  EXPECT_FALSE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId,
                           "chrome://file-manager/?import-crostini-image"));
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId, test_id));

  crostini_features.set_root_access_allowed(true);
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId,
                           "chrome://file-manager/?install-linux-package"));
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId, test_id));

  crostini_features.set_root_access_allowed(false);
  EXPECT_FALSE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId,
                           "chrome://file-manager/?install-linux-package"));
  EXPECT_TRUE(
      FileHandlerIsEnabled(&test_profile, kFileManagerSwaAppId, test_id));
}

class FileManagerFileTaskWithAppServiceTest : public testing::Test {
 public:
  void SetUp() override {
    TestingProfile::Builder profile_builder;
    profile_ = profile_builder.Build();
    app_service_test_.SetUp(profile_.get());
    app_service_proxy_ =
        apps::AppServiceProxyFactory::GetForProfile(profile_.get());
    ASSERT_TRUE(app_service_proxy_);
  }

  void AddFakeAppToAppService(const std::string& app_id,
                              const std::optional<std::string>& package_name,
                              std::vector<std::string> policy_ids,
                              apps::AppType app_type) {
    auto app = std::make_unique<apps::App>(app_type, app_id);
    app->app_id = app_id;
    app->app_type = app_type;
    app->publisher_id = package_name;
    app->policy_ids = std::move(policy_ids);
    app->readiness = apps::Readiness::kReady;

    std::vector<apps::AppPtr> apps;
    apps.push_back(std::move(app));
    app_service_proxy()->OnApps(std::move(apps), app_type,
                                false /* should_notify_initialized */);
  }

  TestingProfile* profile() { return profile_.get(); }
  apps::AppServiceProxy* app_service_proxy() { return app_service_proxy_; }

 private:
  content::BrowserTaskEnvironment task_environment_;
  std::unique_ptr<TestingProfile> profile_;
  raw_ptr<apps::AppServiceProxy> app_service_proxy_ = nullptr;
  apps::AppServiceTest app_service_test_;
};

using AppIdPolicyIdPair = std::pair<const char*, const char*>;

class FileManagerFileTaskPolicyDefaultHandlersTest
    : public FileManagerFileTaskWithAppServiceTest {
 public:
  void SetUp() override {
    FileManagerFileTaskWithAppServiceTest::SetUp();
    CreateAppsAndTasks();
  }

  void TearDown() override { GetTestVirtualTasks().clear(); }

 protected:
  void UpdateDefaultHandlersPrefs(
      const std::vector<std::pair<std::string, std::string>>& handlers = {}) {
    base::Value::Dict pref_dict;
    for (const auto& [file_extension, policy_id] : handlers) {
      pref_dict.Set(file_extension, policy_id);
    }
    profile()->GetTestingPrefService()->SetDict(
        prefs::kDefaultHandlersForFileExtensions, std::move(pref_dict));
  }

  ResultingTasks* resulting_tasks() { return resulting_tasks_.get(); }
  std::vector<extensions::EntryInfo>& entries() { return entries_; }

  void CheckCorrectPolicyAssignment(std::string_view default_app_id) {
    ASSERT_EQ(resulting_tasks()->policy_default_handler_status,
              PolicyDefaultHandlerStatus::kDefaultHandlerAssignedByPolicy);
    ASSERT_EQ(std::ranges::count_if(resulting_tasks()->tasks, &IsDefaultTask),
              1);
    ASSERT_EQ(std::ranges::find_if(resulting_tasks()->tasks, &IsDefaultTask)
                  ->task_descriptor.app_id,
              default_app_id);
  }

  void CheckCorrectPolicyAssignmentForVirtualTask(
      std::string_view virtual_task_id) {
    ASSERT_EQ(resulting_tasks()->policy_default_handler_status,
              PolicyDefaultHandlerStatus::kDefaultHandlerAssignedByPolicy);
    ASSERT_EQ(std::ranges::count_if(resulting_tasks()->tasks, &IsDefaultTask),
              1);
    const auto& task =
        std::ranges::find_if(resulting_tasks()->tasks, &IsDefaultTask)
            ->task_descriptor;
    ASSERT_TRUE(IsVirtualTask(task));
    ASSERT_THAT(task.action_id, testing::EndsWith(virtual_task_id));
  }

  void CheckConflictingPolicyAssignment() {
    ASSERT_EQ(resulting_tasks()->policy_default_handler_status,
              PolicyDefaultHandlerStatus::kIncorrectAssignment);
    ASSERT_EQ(std::ranges::count_if(resulting_tasks()->tasks, &IsDefaultTask),
              0);
  }

  void CheckNoPolicyAssignment() {
    ASSERT_FALSE(resulting_tasks()->policy_default_handler_status);
    ASSERT_EQ(std::ranges::count_if(resulting_tasks()->tasks, &IsDefaultTask),
              0);
  }

 protected:
  static constexpr char kWebAppId[] = "web-app-id";
  static constexpr char kChromeAppId[] = "chrome-app-id";
  static constexpr char kArcAppId[] = "arc-app-id";
  static constexpr char kNonExistentAppId[] = "null";
  static constexpr char kIsolatedAppId[] = "ghgjflengkicinnmfeejkpjmcohegmid";
  static constexpr char kIsolatedPolicyId[] =
      "w2gqjem6b4m7vhiqpjr3btcpp7dxfyjt6h4uuyuxklcsmygtgncaaaac";

  static constexpr char kWebAppUrl[] = "https://web.app";
  static constexpr char kArcAppPackageName[] = "com.package.name";

  static constexpr AppIdPolicyIdPair kAppIdPolicyIdMapping[] = {
      {kWebAppId, kWebAppUrl},
      {kArcAppId, kArcAppPackageName},
      {kChromeAppId, kChromeAppId},
      {kIsolatedAppId, kIsolatedPolicyId}};

 private:
  void CreateAppsAndTasks() {
    resulting_tasks_ = std::make_unique<ResultingTasks>();

    std::vector<FullTaskDescriptor>& tasks = resulting_tasks()->tasks;
    for (const auto& [app_id, _] : kAppIdPolicyIdMapping) {
      tasks.emplace_back(
          TaskDescriptor{app_id, TASK_TYPE_FILE_HANDLER, "action-id"},
          /*task_title=*/"Task", GURL("https://example.com/app.png"), false,
          false, false);
    }

    AddFakeAppToAppService(kWebAppId, /*package_name=*/{},
                           /*policy_ids=*/{kWebAppUrl}, apps::AppType::kWeb);
    AddFakeAppToAppService(kChromeAppId, /*package_name=*/{},
                           /*policy_ids=*/{kChromeAppId},
                           apps::AppType::kChromeApp);
    AddFakeAppToAppService(kArcAppId, /*package_name=*/kArcAppPackageName,
                           /*policy_ids=*/{kArcAppPackageName},
                           apps::AppType::kArc);
    AddFakeAppToAppService(kIsolatedAppId, /*package_name=*/{},
                           /*policy_ids=*/{kIsolatedPolicyId},
                           apps::AppType::kWeb);
  }

  static bool IsDefaultTask(const FullTaskDescriptor& ftd) {
    return ftd.is_default;
  }

  std::unique_ptr<ResultingTasks> resulting_tasks_;
  std::vector<extensions::EntryInfo> entries_;
};

// Check that no default tasks are set if no policy is set.
TEST_F(FileManagerFileTaskPolicyDefaultHandlersTest, CheckNoPolicyAssignment) {
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"),
                         "text/plain", false);

  UpdateDefaultHandlersPrefs(/*empty*/);
  ASSERT_FALSE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                      resulting_tasks()));
  CheckNoPolicyAssignment();
}

// Check that a policy set to a non-existent app is ignored.
TEST_F(FileManagerFileTaskPolicyDefaultHandlersTest,
       CheckAssignmentToNonExistentApp) {
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"),
                         "text/plain", false);

  UpdateDefaultHandlersPrefs({{".txt", kNonExistentAppId}});
  ASSERT_FALSE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                      resulting_tasks()));
  CheckNoPolicyAssignment();
}

// Check that assigning different apps to handle different file extensions
// leads to a conflict.
TEST_F(FileManagerFileTaskPolicyDefaultHandlersTest,
       CheckConflictingPolicyAssignment) {
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"),
                         "text/plain", false);
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.csv"), "text/csv",
                         false);

  UpdateDefaultHandlersPrefs({{".txt", kWebAppUrl}, {".csv", kChromeAppId}});
  ASSERT_TRUE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                     resulting_tasks()));
  CheckConflictingPolicyAssignment();
}

class FileManagerFileTaskVirtualTaskPolicyDefaultHandlersTest
    : public FileManagerFileTaskPolicyDefaultHandlersTest,
      public testing::WithParamInterface<
          std::tuple<std::string, std::string, std::string>> {
 public:
  FileManagerFileTaskVirtualTaskPolicyDefaultHandlersTest() {
    // These feature flags are required to make different virtual tasks
    // discoverable.
    features_.InitWithFeatures({features::kIsolatedWebAppUnmanagedInstall,
                                chromeos::features::kUploadOfficeToCloud},
                               {});
  }

 private:
  base::test::ScopedFeatureList features_;
};

// Check that virtual tasks are handled by the policy.
TEST_P(FileManagerFileTaskVirtualTaskPolicyDefaultHandlersTest, VirtualTask) {
  auto [policy_id, action_id, file_extension] = GetParam();

  const std::string file_name = base::StrCat({"foo", file_extension});
  entries().emplace_back(base::FilePath::FromUTF8Unsafe(file_name),
                         /*mime_type=*/"", /*is_directory=*/false);

  ASSERT_EQ(entries().size(), 1U);
  MatchVirtualTasks(
      profile(), entries(),
      /*file_urls=*/
      {GURL(base::StrCat(
          {"filesystem:chrome://file-manager/external/", file_name}))},
      /*dlp_source_urls=*/{}, &resulting_tasks()->tasks);

  UpdateDefaultHandlersPrefs(
      {{file_extension,
        base::StrCat({apps_util::kVirtualTaskPrefix, policy_id})}});
  ASSERT_TRUE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                     resulting_tasks()));
  CheckCorrectPolicyAssignmentForVirtualTask(action_id);
}

INSTANTIATE_TEST_SUITE_P(
    /**/,
    FileManagerFileTaskVirtualTaskPolicyDefaultHandlersTest,
    testing::Values(
        std::make_tuple("install-isolated-web-app",
                        kActionIdInstallIsolatedWebApp,
                        ".swbn"),
        std::make_tuple("microsoft-office", kActionIdOpenInOffice, ".docx"),
        std::make_tuple("google-docs", kActionIdWebDriveOfficeWord, ".docx"),
        std::make_tuple("google-spreadsheets",
                        kActionIdWebDriveOfficeExcel,
                        ".xlsx"),
        std::make_tuple("google-slides",
                        kActionIdWebDriveOfficePowerPoint,
                        ".pptx")),
    [](const auto& info) {
      const auto& policy_id = std::get<0>(info.param);
      // GoogleTest doesn't allow dashes in test names; the code below
      // changes `xxx-yyy-zzz` policy ids to `XxxYyyZzz` test names.
      return base::JoinString(
          base::ToVector(
              base::SplitString(policy_id, "-",
                                base::WhitespaceHandling::TRIM_WHITESPACE,
                                base::SplitResult::SPLIT_WANT_NONEMPTY),
              [](const std::string& piece) {
                return base::ToUpperASCII(piece[0]) + piece.substr(1);
              }),
          "");
    });

// Check that incorrectly assigned virtual tasks are ignored.
TEST_F(FileManagerFileTaskPolicyDefaultHandlersTest,
       VirtualTaskIncorrectAssignment) {
  auto virtual_task = std::make_unique<FakeVirtualTask>(
      ToSwaActionId(kActionIdInstallIsolatedWebApp));
  GetTestVirtualTasks().push_back(virtual_task.get());

  constexpr char kFileName[] = "foo.txt";

  MatchVirtualTasks(
      profile(),
      {{base::FilePath::FromUTF8Unsafe(kFileName), "text/plain",
        /*is_directory=*/false}},
      /*file_urls=*/
      {GURL(base::StrCat(
          {"filesystem:chrome://file-manager/external/", kFileName}))},
      /*dlp_source_urls=*/{}, &resulting_tasks()->tasks);

  constexpr char kNonExistentVirtualTaskActionId[] = "incorrect-virtual-id";

  UpdateDefaultHandlersPrefs(
      {{".txt", base::StrCat({apps_util::kVirtualTaskPrefix,
                              kNonExistentVirtualTaskActionId})}});
  entries().emplace_back(base::FilePath::FromUTF8Unsafe(kFileName),
                         "text/plain", false);
  ASSERT_FALSE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                      resulting_tasks()));
  CheckNoPolicyAssignment();
}

class FileManagerFileTaskPolicyDefaultHandlersTestPerAppType
    : public FileManagerFileTaskPolicyDefaultHandlersTest,
      public testing::WithParamInterface<AppIdPolicyIdPair> {
 public:
  // This is required to correctly instantiate TEST_SUITE_P.
  using FileManagerFileTaskPolicyDefaultHandlersTest::kAppIdPolicyIdMapping;
};

// Check that default tasks are set correctly by policy_id.
TEST_P(FileManagerFileTaskPolicyDefaultHandlersTestPerAppType,
       ChooseAndSetDefaultTaskFromPolicyPrefsForSingleFileExtension) {
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"),
                         "text/plain", false);

  const auto [app_id, policy_id] = GetParam();
  UpdateDefaultHandlersPrefs({{".txt", policy_id}});
  ASSERT_TRUE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                     resulting_tasks()));
  CheckCorrectPolicyAssignment(app_id);
}

// Check that default tasks are set correctly by policy_id for multiple
// file_extensions.
TEST_P(FileManagerFileTaskPolicyDefaultHandlersTestPerAppType,
       ChooseAndSetDefaultTaskFromPolicyPrefsForMultipleFileExtensions) {
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"),
                         "text/plain", false);
  entries().emplace_back(base::FilePath::FromUTF8Unsafe("foo.csv"), "text/csv",
                         false);

  const auto [app_id, policy_id] = GetParam();
  UpdateDefaultHandlersPrefs({{".txt", policy_id}, {".csv", policy_id}});
  ASSERT_TRUE(ChooseAndSetDefaultTaskFromPolicyPrefs(profile(), entries(),
                                                     resulting_tasks()));
  CheckCorrectPolicyAssignment(app_id);
}

INSTANTIATE_TEST_SUITE_P(
    /**/,
    FileManagerFileTaskPolicyDefaultHandlersTestPerAppType,
    testing::ValuesIn(FileManagerFileTaskPolicyDefaultHandlersTestPerAppType::
                          kAppIdPolicyIdMapping));

class FileManagerFileTaskPreferencesTest
    : public FileManagerFileTaskWithAppServiceTest {
 public:
  // Updates the default task preferences per the given dictionary values.
  // Used for testing ChooseAndSetDefaultTask.
  void UpdateDefaultTaskPreferences(const base::Value::Dict& mime_types,
                                    const base::Value::Dict& suffixes) {
    profile()->GetTestingPrefService()->SetDict(prefs::kDefaultTasksByMimeType,
                                                mime_types.Clone());
    profile()->GetTestingPrefService()->SetDict(prefs::kDefaultTasksBySuffix,
                                                suffixes.Clone());
  }  // namespace file_manager::file_tasks

  const base::Value::Dict& tasks_by_mime_type() {
    return profile()->GetTestingPrefService()->GetDict(
        prefs::kDefaultTasksByMimeType);
  }

  const base::Value::Dict& tasks_by_suffix() {
    return profile()->GetTestingPrefService()->GetDict(
        prefs::kDefaultTasksBySuffix);
  }

  void ClearPrefs() {
    profile()->GetTestingPrefService()->ClearPref(
        prefs::kDefaultTasksByMimeType);
    profile()->GetTestingPrefService()->ClearPref(prefs::kDefaultTasksBySuffix);
  }
};

// Test that the right task is chosen from multiple choices per mime types
// and file extensions.
TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefaultTask_MultipleTasks) {
  // Text.app and Nice.app were found for "foo.txt".
  TaskDescriptor text_app_task("text-app-id", TASK_TYPE_FILE_HANDLER,
                               "action-id");
  TaskDescriptor nice_app_task("nice-app-id", TASK_TYPE_FILE_HANDLER,
                               "action-id");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      text_app_task, "Text.app", GURL("http://example.com/text_app.png"),
      false /* is_default */, false /* is_generic_file_handler */,
      false /* is_file_extension_match */);
  tasks.emplace_back(
      nice_app_task, "Nice.app", GURL("http://example.com/nice_app.png"),
      false /* is_default */, false /* is_generic_file_handler */,
      false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain",
                       false);

  // None of them should be chosen as default, as nothing is set in the
  // preferences.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_FALSE(tasks[0].is_default);
  EXPECT_FALSE(tasks[1].is_default);

  // Set Text.app as default for "text/plain" in the preferences.
  base::Value::Dict empty;
  base::Value::Dict mime_types;
  mime_types.Set("text/plain", base::Value(TaskDescriptorToId(text_app_task)));
  UpdateDefaultTaskPreferences(mime_types, empty);

  // Text.app should be chosen as default.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_TRUE(tasks[0].is_default);
  EXPECT_FALSE(tasks[1].is_default);

  // Change it back to non-default for testing further.
  tasks[0].is_default = false;

  // Clear the preferences and make sure none of them are default.
  UpdateDefaultTaskPreferences(empty, empty);
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_FALSE(tasks[0].is_default);
  EXPECT_FALSE(tasks[1].is_default);

  // Set Nice.app as default for ".txt" in the preferences.
  base::Value::Dict suffixes;
  suffixes.Set(".txt", base::Value(TaskDescriptorToId(nice_app_task)));
  UpdateDefaultTaskPreferences(empty, suffixes);

  // Now Nice.app should be chosen as default.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_FALSE(tasks[0].is_default);
  EXPECT_TRUE(tasks[1].is_default);
}

// Test that internal file browser handler of the Files app is chosen as
// default even if nothing is set in the preferences.
TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefaultTask_FallbackFileBrowser) {
  // The internal file browser handler of the Files app was found for
  // "foo.txt".
  TaskDescriptor files_app_task(
      kFileManagerAppId, TASK_TYPE_FILE_BROWSER_HANDLER, "view-in-browser");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      files_app_task, "View in browser",
      GURL("http://example.com/some_icon.png"), false /* is_default */,
      false /* is_generic_file_handler */, false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain",
                       false);

  // The internal file browser handler should be chosen as default, as it's a
  // fallback file browser handler.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_TRUE(tasks[0].is_default);
}

// Test that Text.app is chosen as default instead of the Files app
// even if nothing is set in the preferences.
TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefaultTask_FallbackTextApp) {
  // Define the browser handler of the Files app for "foo.txt".
  TaskDescriptor files_app_task(
      kFileManagerAppId, TASK_TYPE_FILE_BROWSER_HANDLER, "view-in-browser");
  // Define the text editor app for "foo.txt".
  TaskDescriptor text_app_task(kTextEditorAppId, TASK_TYPE_FILE_HANDLER,
                               "Text");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      files_app_task, "View in browser",
      GURL("http://example.com/some_icon.png"), false /* is_default */,
      false /* is_generic_file_handler */, false /* is_file_extension_match */);
  tasks.emplace_back(
      text_app_task, "Text",
      GURL("chrome://extension-icon/mmfbcljfglbokpmkimbfghdkjmjhdgbg/16/1"),
      false /* is_default */, false /* is_generic_file_handler */,
      false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain",
                       false);

  // The text editor app should be chosen as default, as it's a fallback file
  // browser handler.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_TRUE(tasks[1].is_default);
}

// Test that browser is chosen as default for HTML files instead of the Text
// app even if nothing is set in the preferences.
TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefaultTask_FallbackHtmlTextApp) {
  // Define the browser handler of the Files app for "foo.html".
  TaskDescriptor files_app_task(
      kFileManagerAppId, TASK_TYPE_FILE_BROWSER_HANDLER, "view-in-browser");
  // Define the text editor app for "foo.html".
  TaskDescriptor text_app_task(kTextEditorAppId, TASK_TYPE_FILE_HANDLER,
                               "Text");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      files_app_task, "View in browser",
      GURL("http://example.com/some_icon.png"), false /* is_default */,
      false /* is_generic_file_handler */, false /* is_file_extension_match */);
  tasks.emplace_back(
      text_app_task, "Text",
      GURL("chrome://extension-icon/mmfbcljfglbokpmkimbfghdkjmjhdgbg/16/1"),
      false /* is_default */, false /* is_generic_file_handler */,
      false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("foo.html"), "text/html",
                       false);

  // The internal file browser handler should be chosen as default,
  // as it's a fallback file browser handler.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_TRUE(tasks[0].is_default);
}

// Test that Office Editing is chosen as default even if nothing is set in the
// preferences.
TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefaultTask_FallbackOfficeEditing) {
  // The Office Editing app was found for "slides.pptx".
  TaskDescriptor files_app_task(
      extension_misc::kQuickOfficeComponentExtensionId, TASK_TYPE_FILE_HANDLER,
      "Office Editing for Docs, Sheets & Slides");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      files_app_task, "Office Editing for Docs, Sheets & Slides",
      GURL("chrome://extension-icon/bpmcpldpdmajfigpchkicefoigmkfalc/32/1"),
      false /* is_default */, false /* is_generic_file_handler */,
      false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("slides.pptx"), "",
                       false);

  // The Office Editing app should be chosen as default, as it's a fallback
  // file browser handler.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  EXPECT_TRUE(tasks[0].is_default);
}

// Test that for changes of default app for PDF files, a metric is recorded.
TEST_F(FileManagerFileTaskPreferencesTest,
       UpdateDefaultTask_RecordsPdfDefaultAppChanges) {
  base::UserActionTester user_action_tester;

  // Non-PDF file types are not recorded.
  TaskDescriptor other_app_task("other-app-id", TASK_TYPE_FILE_HANDLER,
                                "action-id");
  UpdateDefaultTask(profile(), other_app_task, {".txt"}, {"text/plain"});
  // Even if it's the Media App.
  TaskDescriptor media_app_task(ash::kMediaAppId, TASK_TYPE_FILE_HANDLER,
                                "action-id");
  UpdateDefaultTask(profile(), media_app_task, {"tiff"}, {"image/tiff"});

  EXPECT_EQ(0, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedAway"));
  EXPECT_EQ(0, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedTo"));

  // PDF files are recorded.
  UpdateDefaultTask(profile(), media_app_task, {".pdf"}, {"application/pdf"});

  EXPECT_EQ(1, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedTo"));
  EXPECT_EQ(0, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedAway"));
  user_action_tester.ResetCounts();

  UpdateDefaultTask(profile(), other_app_task, {".pdf"}, {"application/pdf"});

  EXPECT_EQ(0, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedTo"));
  EXPECT_EQ(1, user_action_tester.GetActionCount(
                   "MediaApp.PDF.DefaultApp.SwitchedAway"));
}

TEST_F(FileManagerFileTaskPreferencesTest,
       ChooseAndSetDefault_MatchesWithAlternateAppServiceTaskDescriptorForm) {
  std::string package = "com.example.gallery";
  std::string activity = "com.example.gallery.OpenActivity";
  std::string app_id = "zabcdefg";
  TaskType task_type = TASK_TYPE_ARC_APP;

  AddFakeAppToAppService(app_id, package, /*policy_ids=*/{},
                         apps::AppType::kArc);

  // Set the default app preference.
  std::string files_app_id = package + "/" + activity;
  TaskDescriptor file_task(files_app_id, task_type, "view");
  base::Value::Dict mime_types;
  mime_types.Set("image/png", base::Value(TaskDescriptorToId(file_task)));
  UpdateDefaultTaskPreferences(mime_types, {});

  // Create the file task descriptors to match against.
  TaskDescriptor app_service_file_task(app_id, task_type, activity);
  TaskDescriptor other_task("other", TASK_TYPE_FILE_BROWSER_HANDLER, "view");

  auto resulting_tasks = std::make_unique<ResultingTasks>();
  std::vector<FullTaskDescriptor>& tasks = resulting_tasks->tasks;

  tasks.emplace_back(
      app_service_file_task, "View Images",
      GURL("http://example.com/some_icon.png"), false /* is_default */,
      false /* is_generic_file_handler */, false /* is_file_extension_match */);
  tasks.emplace_back(other_task, "Other", GURL("http://example.com/other.text"),
                     false /* is_default */,
                     false /* is_generic_file_handler */,
                     false /* is_file_extension_match */);
  std::vector<extensions::EntryInfo> entries;
  entries.emplace_back(base::FilePath::FromUTF8Unsafe("foo.txt"), "image/png",
                       false);

  // Check if the correct task matched against the default preference.
  ChooseAndSetDefaultTask(profile(), entries, resulting_tasks.get());
  ASSERT_TRUE(tasks[0].is_default);
  ASSERT_FALSE(tasks[1].is_default);
}

TEST_F(FileManagerFileTaskPreferencesTest,
       UpdateDefaultTask_ConvertsArcAppServiceTaskDescriptorToStandardTaskId) {
  std::string package = "com.example.gallery";
  std::string activity = "com.example.gallery.OpenActivity";
  std::string app_id = "zabcdefg";
  TaskType task_type = TASK_TYPE_ARC_APP;
  std::string mime_type = "image/png";

  AddFakeAppToAppService(app_id, package, /*policy_ids=*/{},
                         apps::AppType::kArc);

  // Update default task preferences with our task descriptor (which is in the
  // format given from App Service file tasks).
  TaskDescriptor app_service_file_task(app_id, task_type, activity);
  UpdateDefaultTask(profile(), app_service_file_task, {}, {mime_type});

  // Check that the saved default preference is in the right format.
  std::string files_app_id = package + "/" + activity;
  std::string files_task_id = files_app_id + "|arc|view";
  const std::string* default_task_id =
      tasks_by_mime_type().FindString(mime_type);
  ASSERT_EQ(*default_task_id, files_task_id);
}

TEST_F(FileManagerFileTaskPreferencesTest, RemoveDefaultTask) {
  TaskDescriptor app1_view("app1", TASK_TYPE_FILE_BROWSER_HANDLER, "view");
  TaskDescriptor app1_edit("app1", TASK_TYPE_FILE_BROWSER_HANDLER, "edit");
  TaskDescriptor app2_view("app2", TASK_TYPE_FILE_BROWSER_HANDLER, "view");

  UpdateDefaultTask(profile(), app1_view, {"eXT1", "ext2"}, {"mime1", "mime2"});
  UpdateDefaultTask(profile(), app1_edit, {"Ext3"}, {"mime3"});
  UpdateDefaultTask(profile(), app2_view, {"ext4"}, {"mime4"});

  // Removing app1_edit or app2_view should not change app1_view.
  RemoveDefaultTask(profile(), app1_edit, {"ext1"}, {"mime1"});
  RemoveDefaultTask(profile(), app2_view, {"ext1"}, {"mime1"});
  EXPECT_EQ("app1|file|view", *tasks_by_suffix().FindString("ext1"));
  EXPECT_EQ("app1|file|view", *tasks_by_mime_type().FindString("mime1"));

  // Suffix match should be case-insensitive. Only specified suffixes or mimes
  // should be removed, others should not change.
  RemoveDefaultTask(profile(), app1_view, {"Ext1"}, {"mime1"});
  EXPECT_EQ(nullptr, tasks_by_suffix().FindString("ext1"));
  EXPECT_EQ(nullptr, tasks_by_mime_type().FindString("mime1"));
  EXPECT_EQ("app1|file|view", *tasks_by_suffix().FindString("ext2"));
  EXPECT_EQ("app1|file|view", *tasks_by_mime_type().FindString("mime2"));

  // Remove all matches for app1_view.
  RemoveDefaultTask(profile(), app1_view, {"ext1", "ext2"}, {"mime1", "mime2"});
  EXPECT_EQ(nullptr, tasks_by_suffix().FindString("ext1"));
  EXPECT_EQ(nullptr, tasks_by_suffix().FindString("ext2"));
  EXPECT_EQ(nullptr, tasks_by_mime_type().FindString("mime1"));
  EXPECT_EQ(nullptr, tasks_by_mime_type().FindString("mime2"));
}

TEST_F(FileManagerFileTaskPreferencesTest, UpdateDefaultTask_ReplaceExisting) {
  TaskDescriptor app1("app1", TASK_TYPE_FILE_BROWSER_HANDLER, "view");
  TaskDescriptor app2("app2", TASK_TYPE_FILE_BROWSER_HANDLER, "view");

  // Replace-existing true or false both work when no existing task exists.
  UpdateDefaultTask(profile(), app1, {"ext1"}, {"mime1"}, true);
  UpdateDefaultTask(profile(), app2, {"ext2"}, {"mime2"}, false);
  EXPECT_EQ("app1|file|view", *tasks_by_suffix().FindString("ext1"));
  EXPECT_EQ("app2|file|view", *tasks_by_suffix().FindString("ext2"));
  EXPECT_EQ("app1|file|view", *tasks_by_mime_type().FindString("mime1"));
  EXPECT_EQ("app2|file|view", *tasks_by_mime_type().FindString("mime2"));

  // Replace-existing true should overwrite, false should not.
  UpdateDefaultTask(profile(), app2, {"ext1"}, {"mime1"}, true);
  UpdateDefaultTask(profile(), app1, {"ext2"}, {"mime2"}, false);
  EXPECT_EQ("app2|file|view", *tasks_by_suffix().FindString("ext1"));
  EXPECT_EQ("app2|file|view", *tasks_by_suffix().FindString("ext2"));
  EXPECT_EQ("app2|file|view", *tasks_by_mime_type().FindString("mime1"));
  EXPECT_EQ("app2|file|view", *tasks_by_mime_type().FindString("mime2"));
}

}  // namespace file_manager::file_tasks