// Copyright 2020 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/app_service_file_tasks.h"

#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>

#include "ash/constants/ash_features.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/escape.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_feature_list.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_base.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/intent_util.h"
#include "chrome/browser/ash/app_list/arc/arc_app_list_prefs.h"
#include "chrome/browser/ash/crostini/crostini_test_helper.h"
#include "chrome/browser/ash/crostini/fake_crostini_features.h"
#include "chrome/browser/ash/file_manager/file_manager_test_util.h"
#include "chrome/browser/ash/file_manager/file_tasks.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/login/users/fake_chrome_user_manager.h"
#include "chrome/browser/ash/policy/dlp/dlp_files_controller_ash.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/common/pref_names.h"
#include "chrome/test/base/testing_profile.h"
#include "chromeos/ash/components/file_manager/app_id.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/services/app_service/public/cpp/intent_filter.h"
#include "components/services/app_service/public/cpp/intent_test_util.h"
#include "components/services/app_service/public/cpp/intent_util.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "components/user_manager/scoped_user_manager.h"
#include "components/user_manager/test_helper.h"
#include "components/user_manager/user_type.h"
#include "content/public/test/browser_task_environment.h"
#include "extensions/browser/entry_info.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/extension_features.h"
#include "google_apis/gaia/gaia_id.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/features.h"
#include "url/gurl.h"

namespace {
const char kAppIdText[] = "abcdefg";
const char kAppIdImage[] = "gfedcba";
const char kAppIdAny[] = "hijklmn";
const char kChromeAppId[] = "chromeappid";
const char kChromeAppWithVerbsId[] = "chromeappwithverbsid";
const char kExtensionId[] = "extensionid";
const char kAppIdTextWild[] = "zxcvbn";
const char kMimeTypeText[] = "text/plain";
const char kMimeTypeImage[] = "image/jpeg";
const char kMimeTypeHtml[] = "text/html";
const char kMimeTypeAny[] = "*/*";
const char kMimeTypeTextWild[] = "text/*";
const char kFileExtensionText[] = "txt";
const char kFileExtensionImage[] = "jpeg";
const char kFileExtensionAny[] = "fake";
const char kActivityLabelText[] = "some_text_activity";
const char kActivityLabelImage[] = "some_image_activity";
const char kActivityLabelAny[] = "some_any_file";
const char kActivityLabelTextWild[] = "some_text_wild_file";

}  // namespace

namespace file_manager {
namespace file_tasks {
using test::AddFakeAppWithIntentFilters;
using test::AddFakeWebApp;

class AppServiceFileTasksTest : public testing::Test {
 protected:
  AppServiceFileTasksTest() = default;
  void SetUp() override {
    profile_ = std::make_unique<TestingProfile>();
    app_service_test_.SetUp(profile_.get());
    app_service_proxy_ =
        apps::AppServiceProxyFactory::GetForProfile(profile_.get());
    ASSERT_TRUE(app_service_proxy_);
    storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
        util::GetDownloadsMountPointName(profile_.get()),
        storage::kFileSystemTypeLocal, storage::FileSystemMountOption(),
        util::GetMyFilesFolderForProfile(profile_.get()));
  }

  Profile* profile() { return profile_.get(); }

  struct FakeFile {
    std::string file_name;
    std::string mime_type;
    bool is_directory = false;
    GURL file_url;
  };

  GURL test_url(const std::string& file_name) {
    GURL url =
        GURL("filesystem:chrome-extension://id/external/" +
             base::EscapeUrlEncodedData(
                 util::GetDownloadsMountPointName(profile()) + "/" + file_name,
                 /*use_plus=*/false));
    EXPECT_TRUE(url.is_valid());
    return url;
  }

  std::vector<FullTaskDescriptor> FindAppServiceTasks(
      const std::vector<FakeFile>& files) {
    auto resulting_tasks = FindAppServiceTasksImpl(files);
    return resulting_tasks->tasks;
  }

  std::unique_ptr<ResultingTasks> FindAppServiceTasksImpl(
      const std::vector<FakeFile>& files) {
    std::vector<extensions::EntryInfo> entries;
    std::vector<GURL> file_urls;
    std::vector<std::string> dlp_source_urls;
    for (const FakeFile& fake_file : files) {
      entries.emplace_back(
          util::GetMyFilesFolderForProfile(profile()).AppendASCII(
              fake_file.file_name),
          fake_file.mime_type, fake_file.is_directory);
      if (fake_file.file_url.is_empty()) {
        file_urls.push_back(test_url(fake_file.file_name));
      } else {
        file_urls.push_back(fake_file.file_url);
      }
      dlp_source_urls.push_back("");
    }

    auto resulting_tasks = std::make_unique<ResultingTasks>();
    file_tasks::FindAppServiceTasks(profile(), entries, file_urls,
                                    dlp_source_urls, &resulting_tasks->tasks);
    // Sort by app ID so we don't rely on ordering.
    std::ranges::sort(
        resulting_tasks->tasks, std::ranges::less(),
        [](const auto& task) { return task.task_descriptor.app_id; });

    return resulting_tasks;
  }

  std::unique_ptr<ResultingTasks> FindAppServiceTasksWithPolicy(
      const std::vector<FakeFile>& files) {
    auto resulting_tasks = FindAppServiceTasksImpl(files);
    ChooseAndSetDefaultTaskFromPolicyPrefs(
        profile(), ConvertFakeFilesToEntryInfos(files), resulting_tasks.get());
    return resulting_tasks;
  }

  void AddTextApp() {
    AddFakeWebApp(kAppIdText, kMimeTypeText, kFileExtensionText,
                  kActivityLabelText, true, app_service_proxy_);
  }

  void AddImageApp() {
    AddFakeWebApp(kAppIdImage, kMimeTypeImage, kFileExtensionImage,
                  kActivityLabelImage, true, app_service_proxy_);
  }

  void AddTextWildApp() {
    AddFakeWebApp(kAppIdTextWild, kMimeTypeTextWild, kFileExtensionAny,
                  kActivityLabelTextWild, true, app_service_proxy_);
  }

  void AddAnyApp() {
    AddFakeWebApp(kAppIdAny, kMimeTypeAny, kFileExtensionAny, kActivityLabelAny,
                  true, app_service_proxy_);
  }

  // Provides file handlers for all extensions and images.
  void AddChromeApp() {
    extensions::ExtensionBuilder baz_app;
    baz_app.SetManifest(
        base::Value::Dict()
            .Set("name", "Baz")
            .Set("version", "1.0.0")
            .Set("manifest_version", 2)
            .Set("app", base::Value::Dict().Set(
                            "background",
                            base::Value::Dict().Set(
                                "scripts",
                                base::Value::List().Append("background.js"))))
            .Set("file_handlers",
                 base::Value::Dict()
                     .Set("any",
                          base::Value::Dict().Set(
                              "extensions",
                              base::Value::List().Append("*").Append("bar")))
                     .Set("image", base::Value::Dict().Set(
                                       "types", base::Value::List().Append(
                                                    "image/*")))));
    baz_app.SetID(kChromeAppId);
    auto filters =
        apps_util::CreateIntentFiltersForChromeApp(baz_app.Build().get());
    AddFakeAppWithIntentFilters(kChromeAppId, std::move(filters),
                                apps::AppType::kChromeApp, true,
                                app_service_proxy_);
  }

  void AddChromeAppWithVerbs() {
    extensions::ExtensionBuilder foo_app;
    foo_app.SetManifest(
        base::Value::Dict()
            .Set("name", "Foo")
            .Set("version", "1.0.0")
            .Set("manifest_version", 2)
            .Set("app", base::Value::Dict().Set(
                            "background",
                            base::Value::Dict().Set(
                                "scripts",
                                base::Value::List().Append("background.js"))))
            .Set("file_handlers",
                 base::Value::Dict()
                     .Set("any_with_directories",
                          base::Value::Dict()
                              .Set("include_directories", true)
                              .Set("types", base::Value::List().Append("*"))
                              .Set("verb", "open_with"))
                     .Set("html_handler",
                          base::Value::Dict()
                              .Set("title", "Html")
                              .Set("types",
                                   base::Value::List().Append("text/html"))
                              .Set("verb", "open_with"))
                     .Set("plain_text",
                          base::Value::Dict()
                              .Set("title", "Plain")
                              .Set("types",
                                   base::Value::List().Append("text/plain")))
                     .Set("share_plain_text",
                          base::Value::Dict()
                              .Set("title", "Share Plain")
                              .Set("types",
                                   base::Value::List().Append("text/plain"))
                              .Set("verb", "share_with"))
                     .Set("any_pack",
                          base::Value::Dict()
                              .Set("types", base::Value::List().Append("*"))
                              .Set("verb", "pack_with"))
                     .Set("plain_text_add_to",
                          base::Value::Dict()
                              .Set("title", "Plain")
                              .Set("types",
                                   base::Value::List().Append("text/plain"))
                              .Set("verb", "add_to"))));
    foo_app.SetID(kChromeAppWithVerbsId);
    auto filters =
        apps_util::CreateIntentFiltersForChromeApp(foo_app.Build().get());
    AddFakeAppWithIntentFilters(kChromeAppWithVerbsId, std::move(filters),
                                apps::AppType::kChromeApp, true,
                                app_service_proxy_);
  }

  // Adds file_browser_handler to handle .txt files.
  void AddExtension() {
    extensions::ExtensionBuilder fbh_app;
    fbh_app.SetManifest(
        base::Value::Dict()
            .Set("name", "Fbh")
            .Set("version", "1.0.0")
            .Set("manifest_version", 2)
            .Set("permissions",
                 base::Value::List().Append("fileBrowserHandler"))
            .Set("file_browser_handlers",
                 base::Value::List().Append(
                     base::Value::Dict()
                         .Set("id", "open")
                         .Set("default_title", "open title")
                         .Set("file_filters", base::Value::List().Append(
                                                  "filesystem:*.txt")))));
    fbh_app.SetID(kExtensionId);
    auto filters =
        apps_util::CreateIntentFiltersForExtension(fbh_app.Build().get());
    AddFakeAppWithIntentFilters(kExtensionId, std::move(filters),
                                apps::AppType::kChromeApp, true,
                                app_service_proxy_);
  }

  // Load an extension from the supplied manifest, then add intent filters.
  void LoadExtension(std::string_view manifest) {
    scoped_refptr<const extensions::Extension> extension =
        extensions::ExtensionBuilder("file handlers").AddJSON(manifest).Build();
    auto filters = apps_util::CreateIntentFiltersForExtension(extension.get());
    AddFakeAppWithIntentFilters(kExtensionId, std::move(filters),
                                apps::AppType::kExtension,
                                /*handles_intents=*/true, app_service_proxy_);
  }

  apps::IntentFilterPtr CreateMimeTypeFileIntentFilter(std::string action,
                                                       std::string mime_type) {
    auto intent_filter = std::make_unique<apps::IntentFilter>();
    intent_filter->AddSingleValueCondition(apps::ConditionType::kAction, action,
                                           apps::PatternMatchType::kLiteral);
    intent_filter->AddSingleValueCondition(apps::ConditionType::kFile,
                                           mime_type,
                                           apps::PatternMatchType::kMimeType);
    return intent_filter;
  }

  apps::IntentFilterPtr CreateExtensionTypeFileIntentFilter(
      std::string action,
      std::string extension_type) {
    auto intent_filter = std::make_unique<apps::IntentFilter>();
    intent_filter->AddSingleValueCondition(apps::ConditionType::kAction, action,
                                           apps::PatternMatchType::kLiteral);
    intent_filter->AddSingleValueCondition(
        apps::ConditionType::kFile, extension_type,
        apps::PatternMatchType::kFileExtension);
    return intent_filter;
  }

  std::string AddArcAppWithIntentFilter(const std::string& package,
                                        const std::string& activity,
                                        apps::IntentFilterPtr intent_filter) {
    std::string app_id = ArcAppListPrefs::GetAppId(package, activity);
    std::vector<apps::IntentFilterPtr> filters;
    filters.push_back(std::move(intent_filter));
    AddFakeAppWithIntentFilters(app_id, std::move(filters), apps::AppType::kArc,
                                true, app_service_proxy_);
    return app_id;
  }

  void AddGuestOsAppWithIntentFilter(std::string app_id,
                                     apps::AppType app_type,
                                     apps::IntentFilterPtr intent_filter) {
    std::vector<apps::IntentFilterPtr> filters;
    filters.push_back(std::move(intent_filter));
    AddFakeAppWithIntentFilters(app_id, std::move(filters), app_type, true,
                                app_service_proxy_);
  }

  std::vector<extensions::EntryInfo> ConvertFakeFilesToEntryInfos(
      const std::vector<FakeFile>& files) {
    std::vector<extensions::EntryInfo> entries;
    for (const FakeFile& fake_file : files) {
      entries.emplace_back(
          util::GetMyFilesFolderForProfile(profile()).AppendASCII(
              fake_file.file_name),
          fake_file.mime_type, fake_file.is_directory);
    }
    return entries;
  }

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

// An app which does not handle intents should not be found even if the filters
// match.
TEST_F(AppServiceFileTasksTest, FindAppServiceFileTasksHandlesIntent) {
  AddFakeWebApp(kAppIdImage, kMimeTypeImage, kFileExtensionImage,
                kActivityLabelImage, false, app_service_proxy_);
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.jpeg", kMimeTypeImage}});
  ASSERT_EQ(0U, tasks.size());
}

// Test that between an image app and text app, the text app can be
// found for an text file entry.
TEST_F(AppServiceFileTasksTest, FindAppServiceFileTasksText) {
  AddTextApp();
  AddImageApp();
  // Find apps for a "text/plain" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kAppIdText, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasks[0].task_title);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
}

// Test that between an image app and text app, the image app can be
// found for an image file entry.
TEST_F(AppServiceFileTasksTest, FindAppServiceFileTasksImage) {
  AddTextApp();
  AddImageApp();
  // Find apps for a "image/jpeg" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"bar.jpeg", kMimeTypeImage}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kAppIdImage, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelImage, tasks[0].task_title);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
}

// Test that between an image app, text app and an app that can handle every
// file, the app that can handle every file can be found for an image file entry
// and text file entry.
TEST_F(AppServiceFileTasksTest, FindAppServiceFileTasksMultiple) {
  AddTextApp();
  AddImageApp();
  AddAnyApp();
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks(
      {{"foo.txt", kMimeTypeText}, {"bar.jpeg", kMimeTypeImage}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kAppIdAny, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelAny, tasks[0].task_title);
  EXPECT_TRUE(tasks[0].is_generic_file_handler);
}

// Don't register any apps and check that we get no matches.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksNoTasks) {
  // Find web apps for a "text/plain" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(0U, tasks.size());
}

// Register a text handler and check we get no matches with an image.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksNoMatchingTask) {
  AddTextApp();
  // Find apps for a "image/jpeg" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"bar.jpeg", kMimeTypeImage}});
  ASSERT_EQ(0U, tasks.size());
}

// Check we get a match for a text file + web app.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksText) {
  AddTextApp();
  // Find web apps for a "text/plain" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kAppIdText, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasks[0].task_title);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
}

// Check that a web app that only handles text does not match when we have both
// a text file and an image.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksTwoFilesNoMatch) {
  AddTextApp();
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks(
      {{"foo.txt", kMimeTypeText}, {"bar.jpeg", kMimeTypeImage}});
  ASSERT_EQ(0U, tasks.size());
}

// Check we get a match for a text file + text wildcard filter.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksTextWild) {
  AddTextWildApp();
  AddTextApp();
  // Find web apps for a "text/plain" file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(2U, tasks.size());
  EXPECT_EQ(kAppIdText, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasks[0].task_title);
  EXPECT_EQ(kAppIdTextWild, tasks[1].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelTextWild, tasks[1].task_title);
}

// Check we get a match for a text file and HTML file + text wildcard filter.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksTextWildMultiple) {
  AddTextWildApp();
  AddTextApp();   // Should not be matched.
  AddImageApp();  // Should not be matched.
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks(
      {{"foo.txt", kMimeTypeText}, {"bar.html", kMimeTypeHtml}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kAppIdTextWild, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelTextWild, tasks[0].task_title);
}

// An edge case where we have one file that matches the mime type but not the
// file extension, and another file that matches the file extension but not the
// mime type. This should still match the handler.
TEST_F(AppServiceFileTasksTest, FindAppServiceWebFileTasksAllFilesMatchEither) {
  AddTextApp();

  // First check that each file alone matches the text app.
  std::vector<FullTaskDescriptor> tasksFoo =
      FindAppServiceTasks({{"foo.txt", "text/plane"}});
  ASSERT_EQ(1U, tasksFoo.size());
  std::vector<FullTaskDescriptor> tasksBar =
      FindAppServiceTasks({{"bar.text", kMimeTypeText}});
  ASSERT_EQ(1U, tasksFoo.size());

  // Now check that both together match.
  std::vector<FullTaskDescriptor> tasksBoth = FindAppServiceTasks(
      {{"foo.txt", "text/plane"}, {"bar.text", kMimeTypeText}});
  ASSERT_EQ(1U, tasksBoth.size());
  EXPECT_EQ(kAppIdText, tasksBoth[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasksBoth[0].task_title);
}

// Check that Baz's ".*" handler, which is generic, is matched.
TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppText) {
  AddChromeApp();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kChromeAppId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("any", tasks[0].task_descriptor.action_id);
  EXPECT_EQ(TASK_TYPE_FILE_HANDLER, tasks[0].task_descriptor.task_type);
  EXPECT_EQ("Baz", tasks[0].task_title);
  EXPECT_TRUE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);
}

// File extension matches with bar, but there is a generic * type as well,
// so the overall match should still be generic.
TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppBar) {
  AddChromeApp();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.bar", kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kChromeAppId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("any", tasks[0].task_descriptor.action_id);
  EXPECT_EQ(TASK_TYPE_FILE_HANDLER, tasks[0].task_descriptor.task_type);
  EXPECT_EQ("Baz", tasks[0].task_title);
  EXPECT_TRUE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);
}

// Check that we can get web apps and Chrome apps in the same call.
TEST_F(AppServiceFileTasksTest, FindAppServiceMultiAppType) {
  AddTextApp();
  AddChromeApp();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(2U, tasks.size());
  EXPECT_EQ(kAppIdText, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasks[0].task_title);
  EXPECT_EQ(TASK_TYPE_WEB_APP, tasks[0].task_descriptor.task_type);
  EXPECT_EQ(kChromeAppId, tasks[1].task_descriptor.app_id);
  EXPECT_EQ("Baz", tasks[1].task_title);
  EXPECT_EQ(TASK_TYPE_FILE_HANDLER, tasks[1].task_descriptor.task_type);
}

// Check that Baz's "image/*" handler is picked because it is not generic,
// because it matches the mime type directly, even though there is an earlier
// generic handler.
TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppImage) {
  AddChromeApp();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"bar.jpeg", kMimeTypeImage}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kChromeAppId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("image", tasks[0].task_descriptor.action_id);
  EXPECT_EQ(TASK_TYPE_FILE_HANDLER, tasks[0].task_descriptor.task_type);
  EXPECT_EQ("Baz", tasks[0].task_title);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppWithVerbs) {
  AddChromeAppWithVerbs();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});

  // We expect that all non-"open_with" handlers are ignored, and that we
  // only get one open_with handler.
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kChromeAppWithVerbsId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("Foo", tasks[0].task_title);
  EXPECT_EQ("plain_text", tasks[0].task_descriptor.action_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppWithVerbs_Html) {
  AddChromeAppWithVerbs();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.html", kMimeTypeHtml}});

  // Check that we get the non-generic handler which appears later in the
  // manifest.
  EXPECT_EQ(kChromeAppWithVerbsId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("Foo", tasks[0].task_title);
  EXPECT_EQ("html_handler", tasks[0].task_descriptor.action_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceChromeAppWithVerbs_Directory) {
  AddChromeAppWithVerbs();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"dir", "", true}});

  // Only one handler handles directories.
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kChromeAppWithVerbsId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("Foo", tasks[0].task_title);
  EXPECT_EQ("any_with_directories", tasks[0].task_descriptor.action_id);
  EXPECT_TRUE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceExtension) {
  AddExtension();
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});

  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kExtensionId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ("open title", tasks[0].task_title);
  EXPECT_EQ("open", tasks[0].task_descriptor.action_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceArcAppWithExtensionMatching) {
  // Create an app with a text file filter.
  std::string package_name = "com.example.xyzViewer";
  std::string activity = "xyzViewerActivity";
  std::string app_id = AddArcAppWithIntentFilter(
      package_name, activity,
      CreateExtensionTypeFileIntentFilter(apps_util::kIntentActionView, "xyz"));
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks({{"foo.xyz"}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(app_id, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);
}

// Verify App Service tasks for extensions with MV3 File Handlers.
TEST_F(AppServiceFileTasksTest, FileHandlersFindAppServiceExtension) {
  static constexpr char kAction[] = "/open.html";
  const std::string manifest = base::StringPrintf(R"(
    "version": "0.0.1",
    "manifest_version": 3,
    "file_handlers": [
      {
        "name": "Text file",
        "action": "%s",
        "accept": {"text/plain": ".txt"}
      }
    ]
  )",
                                                  kAction);
  LoadExtension(manifest);
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"test.txt", kMimeTypeText}});

  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(kExtensionId, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kAction, tasks[0].task_descriptor.action_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceArcApp) {
  std::string text_mime_type = "text/plain";
  std::string image_mime_type = "image/jpeg";

  // Create an app with a text file filter.
  std::string text_package_name = "com.example.textViewer";
  std::string text_activity = "TextViewerActivity";
  std::string text_app_id = AddArcAppWithIntentFilter(
      text_package_name, text_activity,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     text_mime_type));

  // Create an app with an image file filter.
  std::string image_package_name = "com.example.imageViewer";
  std::string image_activity = "ImageViewerActivity";
  std::string image_app_id = AddArcAppWithIntentFilter(
      image_package_name, image_activity,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     image_mime_type));

  // Check if only the text ARC app appears as a result.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", text_mime_type}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(text_app_id, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindAppServiceCrostiniApp) {
  std::string file_name = "foo.txt";
  std::string text_app_id = "Text app";
  AddGuestOsAppWithIntentFilter(
      text_app_id, apps::AppType::kCrostini,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     kMimeTypeText));

  // Check if the text Crostini app is returned.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{file_name, kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(text_app_id, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);
}

// Checks that we can detect when the file paths can/ can't be shared for
// Crostini and PluginVm.
TEST_F(AppServiceFileTasksTest, CheckPathsCanBeShared) {
  std::string file_name = "foo.txt";
  std::string text_app_id = "Text app";
  AddGuestOsAppWithIntentFilter(
      text_app_id, apps::AppType::kCrostini,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     kMimeTypeText));

  // Possible to share path.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{file_name, kMimeTypeText}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(text_app_id, tasks[0].task_descriptor.app_id);

  // Should not be possible to share path.
  GURL invalid_url = GURL("broken:url");
  tasks =
      FindAppServiceTasks({{file_name, kMimeTypeText, /*is_directory=*/false,
                            /*file_url=*/invalid_url}});
  ASSERT_EQ(0U, tasks.size());
}

TEST_F(AppServiceFileTasksTest, FindMultipleAppServiceCrostiniApps) {
  std::string file_name = "foo.txt";
  std::string app_id_1 = "Text app 1";
  std::string app_id_2 = "Text app 2";
  AddGuestOsAppWithIntentFilter(
      app_id_1, apps::AppType::kCrostini,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     kMimeTypeText));
  AddGuestOsAppWithIntentFilter(
      app_id_2, apps::AppType::kCrostini,
      CreateMimeTypeFileIntentFilter(apps_util::kIntentActionView,
                                     kMimeTypeText));

  // Check if both Crostini apps are returned.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{file_name, kMimeTypeText}});
  ASSERT_EQ(2U, tasks.size());

  EXPECT_EQ(app_id_1, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_FALSE(tasks[0].is_file_extension_match);

  EXPECT_EQ(app_id_2, tasks[1].task_descriptor.app_id);
  EXPECT_FALSE(tasks[1].is_generic_file_handler);
  EXPECT_FALSE(tasks[1].is_file_extension_match);
}

// When we encounter a file with an unknown mime-type (i.e.
// application/octet-stream), we rely on matching with the extension type. Check
// whether extension matching works for Crostini.
TEST_F(AppServiceFileTasksTest, FindAppServiceCrostiniAppWithExtension) {
  std::string extension = "randomExtension";
  std::string mime_type = "test/randomMimeType";
  std::string file_name = "foo." + extension;
  std::string app_id = "App";

  auto intent_filter =
      apps_util::CreateFileFilter({apps_util::kIntentActionView}, {mime_type},
                                  {extension}, "open-with", false);
  AddGuestOsAppWithIntentFilter(app_id, apps::AppType::kCrostini,
                                std::move(intent_filter));

  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{file_name, "application/octet-stream"}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(app_id, tasks[0].task_descriptor.app_id);
}

TEST_F(AppServiceFileTasksTest, FindAppServicePluginVmApp) {
  std::string file_ext = "txt";
  std::string file_name = "foo." + file_ext;
  std::string text_app_id = "Text app";
  AddGuestOsAppWithIntentFilter(text_app_id, apps::AppType::kPluginVm,
                                CreateExtensionTypeFileIntentFilter(
                                    apps_util::kIntentActionView, file_ext));

  // Check if the text PluginVm app is returned.
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks({{file_name}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(text_app_id, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, FindMultipleAppServicePluginVmApps) {
  std::string file_ext = "txt";
  std::string file_name = "foo." + file_ext;
  std::string app_id_1 = "Text app 1";
  std::string app_id_2 = "Text app 2";
  AddGuestOsAppWithIntentFilter(app_id_1, apps::AppType::kPluginVm,
                                CreateExtensionTypeFileIntentFilter(
                                    apps_util::kIntentActionView, file_ext));
  AddGuestOsAppWithIntentFilter(app_id_2, apps::AppType::kPluginVm,
                                CreateExtensionTypeFileIntentFilter(
                                    apps_util::kIntentActionView, file_ext));

  // Check if both PluginVm apps are returned.
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks({{file_name}});
  ASSERT_EQ(2U, tasks.size());

  EXPECT_EQ(app_id_1, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);

  EXPECT_EQ(app_id_2, tasks[1].task_descriptor.app_id);
  EXPECT_FALSE(tasks[1].is_generic_file_handler);
  EXPECT_TRUE(tasks[1].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest,
       FindAppServicePluginVmApp_IgnoringExtensionCase) {
  std::string file_ext = "Txt";
  std::string file_name = "foo.txT";
  std::string text_app_id = "Text app";
  AddGuestOsAppWithIntentFilter(text_app_id, apps::AppType::kPluginVm,
                                CreateExtensionTypeFileIntentFilter(
                                    apps_util::kIntentActionView, file_ext));

  // Check if the text PluginVm app is returned.
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks({{file_name}});
  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(text_app_id, tasks[0].task_descriptor.app_id);
  EXPECT_FALSE(tasks[0].is_generic_file_handler);
  EXPECT_TRUE(tasks[0].is_file_extension_match);
}

TEST_F(AppServiceFileTasksTest, NoPluginVmAppsForFileSelection) {
  std::string image_file_name = "foo.jpeg";
  std::string image_app_id = "Image app";
  std::string text_file_name = "foo.txt";
  std::string text_app_id = "Text app";

  // Add a text-only app and an image-only app.
  AddGuestOsAppWithIntentFilter(
      text_app_id, apps::AppType::kPluginVm,
      CreateExtensionTypeFileIntentFilter(apps_util::kIntentActionView, "txt"));
  AddGuestOsAppWithIntentFilter(image_app_id, apps::AppType::kPluginVm,
                                CreateExtensionTypeFileIntentFilter(
                                    apps_util::kIntentActionView, "jpeg"));

  // Find an app that can open both the text and image file.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{text_file_name}, {image_file_name}});

  // There shouldn't be any apps available.
  ASSERT_EQ(0U, tasks.size());
}

TEST_F(AppServiceFileTasksTest, CrositiniTasksControlledByPolicy) {
  std::string tini_task_name = "chrome://file-manager/?import-crostini-image";
  std::string deb_task_name = "chrome://file-manager/?install-linux-package";
  std::vector<apps::IntentFilterPtr> filters;
  filters.push_back(
      apps_util::MakeFileFilterForView("tini", "tini", "import-tini"));
  filters[0]->activity_name = tini_task_name;
  filters.push_back(
      apps_util::MakeFileFilterForView("deb", "deb", "import-deb"));
  filters[1]->activity_name = deb_task_name;
  AddFakeAppWithIntentFilters(file_manager::kFileManagerSwaAppId,
                              std::move(filters), apps::AppType::kWeb, true,
                              app_service_proxy_);

  std::string file_name = "test.tini";

  crostini::FakeCrostiniFeatures crostini_features;
  crostini_features.set_export_import_ui_allowed(true);
  std::vector<FullTaskDescriptor> tasks = FindAppServiceTasks({{file_name}});

  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(file_manager::kFileManagerSwaAppId,
            tasks[0].task_descriptor.app_id);
  EXPECT_EQ(tini_task_name, tasks[0].task_descriptor.action_id);

  crostini_features.set_export_import_ui_allowed(false);
  tasks = FindAppServiceTasks({{file_name}});

  ASSERT_EQ(0U, tasks.size());

  file_name = "test.deb";

  crostini_features.set_root_access_allowed(true);
  tasks = FindAppServiceTasks({{file_name}});

  ASSERT_EQ(1U, tasks.size());
  EXPECT_EQ(file_manager::kFileManagerSwaAppId,
            tasks[0].task_descriptor.app_id);
  EXPECT_EQ(deb_task_name, tasks[0].task_descriptor.action_id);

  crostini_features.set_root_access_allowed(false);
  tasks = FindAppServiceTasks({{file_name}});

  ASSERT_EQ(0U, tasks.size());
}

// Tests applying policies when listing tasks.
class AppServiceFileTasksPolicyTest : public AppServiceFileTasksTest {
 protected:
  class MockFilesController : public policy::DlpFilesControllerAsh {
   public:
    explicit MockFilesController(const policy::DlpRulesManager& rules_manager,
                                 Profile* profile)
        : DlpFilesControllerAsh(rules_manager, profile) {}
    ~MockFilesController() override = default;

    MOCK_METHOD(bool,
                IsLaunchBlocked,
                (const apps::AppUpdate&, const apps::IntentPtr&),
                (override));
  };

  AppServiceFileTasksPolicyTest() = default;

  std::unique_ptr<KeyedService> SetDlpRulesManager(
      content::BrowserContext* context) {
    auto dlp_rules_manager =
        std::make_unique<testing::NiceMock<policy::MockDlpRulesManager>>(
            Profile::FromBrowserContext(context));
    rules_manager_ = dlp_rules_manager.get();
    return dlp_rules_manager;
  }

  void SetUp() override {
    AppServiceFileTasksTest::SetUp();

    AccountId account_id =
        AccountId::FromUserEmailGaiaId("test@example.com", GaiaId("12345"));
    profile_->SetIsNewProfile(true);
    fake_user_manager_->AddUserWithAffiliationAndTypeAndProfile(
        account_id, /*is_affiliated=*/false, user_manager::UserType::kRegular,
        profile_.get());
    fake_user_manager_->UserLoggedIn(
        account_id, user_manager::TestHelper::GetFakeUsernameHash(account_id));
    fake_user_manager_->SimulateUserProfileLoad(account_id);

    policy::DlpRulesManagerFactory::GetInstance()->SetTestingFactory(
        profile_.get(),
        base::BindRepeating(&AppServiceFileTasksPolicyTest::SetDlpRulesManager,
                            base::Unretained(this)));
    ASSERT_TRUE(policy::DlpRulesManagerFactory::GetForPrimaryProfile());

    ON_CALL(*rules_manager_, IsFilesPolicyEnabled)
        .WillByDefault(testing::Return(true));
    mock_files_controller_ =
        std::make_unique<MockFilesController>(*rules_manager_, profile_.get());
    ON_CALL(*rules_manager_, GetDlpFilesController)
        .WillByDefault(testing::Return(mock_files_controller_.get()));
  }

  void TearDown() override { fake_user_manager_.Reset(); }

  raw_ptr<policy::MockDlpRulesManager> rules_manager_ = nullptr;
  std::unique_ptr<MockFilesController> mock_files_controller_ = nullptr;
  user_manager::TypedScopedUserManager<ash::FakeChromeUserManager>
      fake_user_manager_{std::make_unique<ash::FakeChromeUserManager>()};
};

// Test that out of two apps, one can be blocked by DLP and the other allowed.
TEST_F(AppServiceFileTasksPolicyTest, FindAppServiceFileTasksText_DlpChecked) {
  EXPECT_CALL(*mock_files_controller_.get(), IsLaunchBlocked)
      .WillOnce(testing::Return(false))
      .WillOnce(testing::Return(true));

  AddTextApp();
  AddAnyApp();
  // Find apps for a "text/plain" file. First app shouldn't be blocked, but the
  // second one yes.
  std::vector<FullTaskDescriptor> tasks =
      FindAppServiceTasks({{"foo.txt", kMimeTypeText}});
  ASSERT_EQ(2U, tasks.size());
  EXPECT_EQ(kAppIdText, tasks[0].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelText, tasks[0].task_title);
  EXPECT_FALSE(tasks[0].is_dlp_blocked);
  EXPECT_EQ(kAppIdAny, tasks[1].task_descriptor.app_id);
  EXPECT_EQ(kActivityLabelAny, tasks[1].task_title);
  EXPECT_TRUE(tasks[1].is_dlp_blocked);
}

}  // namespace file_tasks
}  // namespace file_manager.