// Copyright 2022 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/apps/app_preload_service/app_preload_service.h"

#include <algorithm>
#include <memory>

#include "base/functional/callback_forward.h"
#include "base/memory/scoped_refptr.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_future.h"
#include "chrome/browser/apps/app_preload_service/app_preload_almanac_endpoint.h"
#include "chrome/browser/apps/app_preload_service/app_preload_service_factory.h"
#include "chrome/browser/apps/app_preload_service/proto/app_preload.pb.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/ash/app_list/arc/arc_app_list_prefs.h"
#include "chrome/browser/ash/settings/scoped_testing_cros_settings.h"
#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
#include "chrome/common/chrome_features.h"
#include "chrome/test/base/scoped_testing_local_state.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile.h"
#include "chromeos/ash/components/settings/cros_settings.h"
#include "chromeos/ash/components/system/fake_statistics_provider.h"
#include "components/prefs/pref_service.h"
#include "components/services/app_service/public/cpp/app_registry_cache.h"
#include "components/services/app_service/public/cpp/app_update.h"
#include "components/user_manager/fake_user_manager_delegate.h"
#include "components/user_manager/scoped_user_manager.h"
#include "components/user_manager/user_manager.h"
#include "components/user_manager/user_manager_impl.h"
#include "content/public/test/browser_task_environment.h"
#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
#include "services/network/test/test_url_loader_factory.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {

constexpr char kFirstLoginFlowStartedKey[] = "first_login_flow_started";
constexpr char kFirstLoginFlowCompletedKey[] = "first_login_flow_completed";

constexpr char kApsStateManager[] = "apps.app_preload_service.state_manager";

const base::Value::Dict& GetStateManager(Profile* profile) {
  return profile->GetPrefs()->GetDict(kApsStateManager);
}

}  // namespace

namespace apps {

class AppPreloadServiceTest : public testing::Test {
 protected:
  AppPreloadServiceTest()
      : startup_check_resetter_(
            AppPreloadService::DisablePreloadsOnStartupForTesting()) {
    scoped_feature_list_.InitWithFeatures(
        {features::kAppPreloadService, kAppPreloadServiceEnableShelfPin}, {});
    AppPreloadServiceFactory::SkipApiKeyCheckForTesting(true);
  }

  void SetUp() override {
    testing::Test::SetUp();

    user_manager::UserManager::Get()->SetIsCurrentUserNew(true);

    TestingProfile::Builder profile_builder;
    profile_builder.SetSharedURLLoaderFactory(
        url_loader_factory_.GetSafeWeakWrapper());
    profile_ = profile_builder.Build();

    web_app::test::AwaitStartWebAppProviderAndSubsystems(GetProfile());
  }

  void TearDown() override {
    AppPreloadServiceFactory::SkipApiKeyCheckForTesting(false);
  }

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

  network::TestURLLoaderFactory url_loader_factory_;

 private:
  // BrowserTaskEnvironment has to be the first member or test will break.
  content::BrowserTaskEnvironment task_environment_;
  base::test::ScopedFeatureList scoped_feature_list_;
  ScopedTestingLocalState testing_local_state_{
      TestingBrowserProcess::GetGlobal()};
  ash::ScopedTestingCrosSettings testing_cros_settings_;
  user_manager::ScopedUserManager scoped_user_manager_{
      std::make_unique<user_manager::UserManagerImpl>(
          std::make_unique<user_manager::FakeUserManagerDelegate>(),
          testing_local_state_.Get(),
          ash::CrosSettings::Get())};
  std::unique_ptr<TestingProfile> profile_;
  ash::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
  base::AutoReset<bool> startup_check_resetter_;
};

TEST_F(AppPreloadServiceTest, ServiceAccessPerProfile) {
  // We expect the App Preload Service to be available in a normal profile.
  TestingProfile::Builder profile_builder;
  auto profile = profile_builder.Build();
  EXPECT_TRUE(AppPreloadServiceFactory::IsAvailable(profile.get()));
  auto* service = AppPreloadServiceFactory::GetForProfile(profile.get());
  EXPECT_NE(nullptr, service);

  // The service is unsupported in incognito.
  TestingProfile::Builder incognito_builder;
  auto* incognito_profile = incognito_builder.BuildIncognito(profile.get());
  EXPECT_FALSE(AppPreloadServiceFactory::IsAvailable(incognito_profile));
  EXPECT_EQ(nullptr,
            AppPreloadServiceFactory::GetForProfile(incognito_profile));

  // We expect the App Preload Service to not be available in either regular or
  // OTR guest profiles.
  TestingProfile::Builder guest_builder;
  guest_builder.SetGuestSession();
  auto guest_profile = guest_builder.Build();
  EXPECT_FALSE(AppPreloadServiceFactory::IsAvailable(guest_profile.get()));
  EXPECT_EQ(nullptr,
            AppPreloadServiceFactory::GetForProfile(guest_profile.get()));

  auto* guest_otr_profile =
      guest_profile->GetPrimaryOTRProfile(/*create_if_needed=*/true);
  EXPECT_FALSE(AppPreloadServiceFactory::IsAvailable(guest_otr_profile));
  EXPECT_EQ(nullptr,
            AppPreloadServiceFactory::GetForProfile(guest_otr_profile));

  // The service is unsupported for managed and supervised accounts.
  TestingProfile::Builder child_builder;
  child_builder.SetIsSupervisedProfile();
  std::unique_ptr<TestingProfile> child_profile = child_builder.Build();

  EXPECT_FALSE(AppPreloadServiceFactory::IsAvailable(child_profile.get()));
  EXPECT_EQ(nullptr,
            AppPreloadServiceFactory::GetForProfile(child_profile.get()));

  TestingProfile::Builder managed_builder;
  managed_builder.OverridePolicyConnectorIsManagedForTesting(true);
  std::unique_ptr<TestingProfile> managed_profile = managed_builder.Build();

  EXPECT_FALSE(AppPreloadServiceFactory::IsAvailable(managed_profile.get()));
  EXPECT_EQ(nullptr,
            AppPreloadServiceFactory::GetForProfile(managed_profile.get()));
}

TEST_F(AppPreloadServiceTest, FirstLoginStartedPrefSet) {
  auto* service = AppPreloadService::Get(GetProfile());
  // Start the login flow, but do not wait for it to finish.
  service->StartFirstLoginFlowForTesting(base::DoNothing());

  auto flow_started =
      GetStateManager(GetProfile()).FindBool(kFirstLoginFlowStartedKey);
  auto flow_completed =
      GetStateManager(GetProfile()).FindBool(kFirstLoginFlowCompletedKey);
  // Since we're creating a new profile with no saved state, we expect the state
  // to be "started", but not "completed".
  EXPECT_TRUE(flow_started.has_value() && flow_started.value());
  EXPECT_EQ(flow_completed, std::nullopt);
}

TEST_F(AppPreloadServiceTest, FirstLoginCompletedPrefSetAfterSuccess) {
  // An empty response indicates that the request completed successfully, but
  // there are no apps to install.
  proto::AppPreloadListResponse response;

  url_loader_factory_.AddResponse(
      app_preload_almanac_endpoint::GetServerUrl().spec(),
      response.SerializeAsString());

  base::test::TestFuture<bool> result;
  auto* service = AppPreloadService::Get(GetProfile());
  service->StartFirstLoginFlowForTesting(result.GetCallback());
  ASSERT_TRUE(result.Get());

  // We expect that the key has been set after the first login flow has been
  // completed.
  auto flow_completed =
      GetStateManager(GetProfile()).FindBool(kFirstLoginFlowCompletedKey);
  EXPECT_NE(flow_completed, std::nullopt);
  EXPECT_TRUE(flow_completed.value());
}

TEST_F(AppPreloadServiceTest, FirstLoginExistingUserNotStarted) {
  user_manager::UserManager::Get()->SetIsCurrentUserNew(false);
  TestingProfile existing_user_profile;

  auto* service = AppPreloadService::Get(&existing_user_profile);
  service->StartFirstLoginFlowForTesting(base::DoNothing());

  auto flow_started = GetStateManager(&existing_user_profile)
                          .FindBool(kFirstLoginFlowStartedKey);
  // Existing users should not start the first-login flow.
  EXPECT_FALSE(flow_started.has_value());
}

TEST_F(AppPreloadServiceTest, IgnoreAndroidAppInstall) {
  constexpr char kPackageName[] = "com.peanuttypes";
  constexpr char kActivityName[] = "com.peanuttypes.PeanutTypesActivity";

  proto::AppPreloadListResponse response;
  auto* app = response.add_apps_to_install();
  app->set_name("Peanut Types");
  app->set_install_reason(proto::AppPreloadListResponse::INSTALL_REASON_OEM);

  url_loader_factory_.AddResponse(
      app_preload_almanac_endpoint::GetServerUrl().spec(),
      response.SerializeAsString());

  base::test::TestFuture<bool> result;
  auto* service = AppPreloadService::Get(GetProfile());
  service->StartFirstLoginFlowForTesting(result.GetCallback());
  ASSERT_TRUE(result.Get());

  // It's hard to assert conclusively that nothing happens in this case, but for
  // now we just assert that the app wasn't added to App Service.
  auto app_id = ArcAppListPrefs::GetAppId(kPackageName, kActivityName);
  bool found = AppServiceProxyFactory::GetForProfile(GetProfile())
                   ->AppRegistryCache()
                   .ForOneApp(app_id, [](const AppUpdate&) {});
  ASSERT_FALSE(found);
}

TEST_F(AppPreloadServiceTest, FirstLoginStartedNotCompletedAfterServerError) {
  url_loader_factory_.AddResponse(
      app_preload_almanac_endpoint::GetServerUrl().spec(), /*content=*/"",
      net::HTTP_INTERNAL_SERVER_ERROR);

  base::test::TestFuture<bool> result;
  auto* service = AppPreloadService::Get(GetProfile());
  service->StartFirstLoginFlowForTesting(result.GetCallback());
  ASSERT_FALSE(result.Get());

  auto flow_started =
      GetStateManager(GetProfile()).FindBool(kFirstLoginFlowStartedKey);
  auto flow_completed =
      GetStateManager(GetProfile()).FindBool(kFirstLoginFlowCompletedKey);
  // Since there was an error fetching apps, the flow should be "started" but
  // not "completed".
  EXPECT_EQ(flow_started, true);
  EXPECT_EQ(flow_completed, std::nullopt);
}

TEST_F(AppPreloadServiceTest, GetPinApps) {
  PackageId app1 = *PackageId::FromString("web:https://example.com/app1");
  PackageId app2 = *PackageId::FromString("web:https://example.com/app2");
  PackageId app3 = *PackageId::FromString("web:https://example.com/app3");
  PackageId app4 = *PackageId::FromString("web:https://example.com/app4");

  proto::AppPreloadListResponse response;
  auto add_app = [&](const std::string& package_id) {
    auto* app = response.add_apps_to_install();
    app->set_package_id(package_id);
    app->set_install_reason(
        proto::AppPreloadListResponse::INSTALL_REASON_DEFAULT);
  };
  auto add_shelf_config = [&](const std::string& package_id, uint32_t order) {
    auto* config = response.add_shelf_config();
    config->add_package_id(package_id);
    config->set_order(order);
  };
  add_app(app4.ToString());
  add_app(app2.ToString());
  add_app(app1.ToString());
  add_shelf_config(app3.ToString(), 3);
  add_shelf_config(app2.ToString(), 2);
  add_shelf_config(app1.ToString(), 1);

  url_loader_factory_.AddResponse(
      app_preload_almanac_endpoint::GetServerUrl().spec(),
      response.SerializeAsString());

  auto* service = AppPreloadService::Get(GetProfile());
  service->StartFirstLoginFlowForTesting(base::DoNothing());

  base::test::TestFuture<const std::vector<PackageId>&,
                         const std::vector<PackageId>&>
      result;
  service->GetPinApps(result.GetCallback());

  // Pin apps should ignore app4 since it is not in pin ordering.
  std::vector<apps::PackageId> pin_apps = result.Get<0>();
  EXPECT_EQ(pin_apps.size(), 2u);
  EXPECT_EQ(pin_apps[0], app2);
  EXPECT_EQ(pin_apps[1], app1);

  // Pin order should be sorted.
  std::vector<apps::PackageId> pin_order = result.Get<1>();
  EXPECT_EQ(pin_order.size(), 3u);
  EXPECT_EQ(pin_order[0], app1);
  EXPECT_EQ(pin_order[1], app2);
  EXPECT_EQ(pin_order[2], app3);
}

}  // namespace apps