// 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/child_accounts/time_limits/app_activity_registry.h"

#include <map>
#include <memory>
#include <optional>
#include <vector>

#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "base/unguessable_token.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_service_wrapper.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_time_limit_utils.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_time_limits_allowlist_policy_test_utils.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_time_limits_allowlist_policy_wrapper.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_time_notification_delegate.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_types.h"
#include "chrome/browser/ash/child_accounts/time_limits/persisted_app_info.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/views/chrome_views_test_base.h"
#include "components/prefs/pref_service.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "extensions/common/constants.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/client/window_types.h"
#include "ui/aura/window.h"

namespace ash {
namespace app_time {

namespace {

const AppId kApp1(apps::AppType::kArc, "1");
const AppId kApp2(apps::AppType::kWeb, "3");
const AppId kGoogleSlidesApp(apps::AppType::kChromeApp,
                             extension_misc::kGoogleSlidesAppId);

class AppTimeNotificationDelegateMock : public AppTimeNotificationDelegate {
 public:
  AppTimeNotificationDelegateMock() = default;
  AppTimeNotificationDelegateMock(const AppTimeNotificationDelegateMock&) =
      delete;
  AppTimeNotificationDelegateMock& operator=(
      const AppTimeNotificationDelegateMock&) = delete;

  ~AppTimeNotificationDelegateMock() override = default;

  MOCK_METHOD3(ShowAppTimeLimitNotification,
               void(const AppId&,
                    const std::optional<base::TimeDelta>&,
                    AppNotification));
};

class AppStateObserverMock : public AppActivityRegistry::AppStateObserver {
 public:
  AppStateObserverMock() = default;
  AppStateObserverMock(const AppStateObserverMock&) = delete;
  AppStateObserverMock& operator=(const AppStateObserverMock&) = delete;

  ~AppStateObserverMock() override = default;

  MOCK_METHOD3(OnAppLimitReached, void(const AppId&, base::TimeDelta, bool));
  MOCK_METHOD1(OnAppLimitRemoved, void(const AppId&));
  MOCK_METHOD1(OnAppInstalled, void(const AppId&));
};

}  // namespace

class AppActivityRegistryTest : public ChromeViewsTestBase {
 protected:
  AppActivityRegistryTest() = default;
  AppActivityRegistryTest(const AppActivityRegistryTest&) = delete;
  AppActivityRegistryTest& operator=(const AppActivityRegistryTest&) = delete;
  ~AppActivityRegistryTest() override = default;

  // ChromeViewsTestBase:
  void SetUp() override;

  void InstallApps();

  base::UnguessableToken CreateInstanceIdForApp(const AppId& app_id);
  base::UnguessableToken GetInstanceIdForApp(const AppId& app_id);

  void SetAppLimit(const AppId& app_id,
                   const std::optional<AppLimit>& app_limit);

  void ReInitializeRegistry();

  AppActivityRegistry& registry() {
    EXPECT_TRUE(registry_.get());
    return *registry_;
  }
  AppActivityRegistry::TestApi& registry_test() {
    EXPECT_TRUE(registry_test_.get());
    return *registry_test_;
  }

  AppTimeNotificationDelegateMock& notification_delegate_mock() {
    return notification_delegate_mock_;
  }
  PrefService* prefs() { return profile_.GetPrefs(); }

  void CreateAppActivityForApp(const AppId& app_id,
                               base::TimeDelta activity_length);

 private:
  TestingProfile profile_;
  AppTimeNotificationDelegateMock notification_delegate_mock_;
  AppServiceWrapper wrapper_{&profile_};
  std::unique_ptr<AppActivityRegistry> registry_;
  std::unique_ptr<AppActivityRegistry::TestApi> registry_test_;

  std::map<AppId, std::vector<base::UnguessableToken>> instance_ids_;
};

void AppActivityRegistryTest::SetUp() {
  ChromeViewsTestBase::SetUp();
  ReInitializeRegistry();
  InstallApps();
}

void AppActivityRegistryTest::InstallApps() {
  registry().OnAppInstalled(GetChromeAppId());
  registry().OnAppInstalled(kApp1);
  registry().OnAppInstalled(kApp2);
  registry().OnAppAvailable(GetChromeAppId());
  registry().OnAppAvailable(kApp1);
  registry().OnAppAvailable(kApp2);
}

base::UnguessableToken AppActivityRegistryTest::CreateInstanceIdForApp(
    const AppId& app_id) {
  base::UnguessableToken instance_id(base::UnguessableToken::Create());
  instance_ids_[app_id].push_back(instance_id);
  return instance_id;
}

base::UnguessableToken AppActivityRegistryTest::GetInstanceIdForApp(
    const AppId& app_id) {
  const std::vector<base::UnguessableToken>& app_windows =
      instance_ids_.at(app_id);
  EXPECT_GE(app_windows.size(), 0u);
  return app_windows[app_windows.size() - 1];
}

void AppActivityRegistryTest::SetAppLimit(
    const AppId& app_id,
    const std::optional<AppLimit>& app_limit) {
  registry().SetAppLimit(app_id, app_limit);
  task_environment()->RunUntilIdle();
}

void AppActivityRegistryTest::ReInitializeRegistry() {
  registry_ = std::make_unique<AppActivityRegistry>(
      &wrapper_, &notification_delegate_mock_, prefs());

  registry_test_ =
      std::make_unique<AppActivityRegistry::TestApi>(registry_.get());
}

void AppActivityRegistryTest::CreateAppActivityForApp(
    const AppId& app_id,
    base::TimeDelta activity_length) {
  auto app_instance_id = CreateInstanceIdForApp(app_id);
  registry().OnAppActive(app_id, app_instance_id, base::Time::Now());
  task_environment()->FastForwardBy(activity_length);
  registry().OnAppInactive(app_id, app_instance_id, base::Time::Now());
}

TEST_F(AppActivityRegistryTest, RunningActiveTimeCheck) {
  auto app1_instance_id = CreateInstanceIdForApp(kApp1);

  base::Time app1_start_time = base::Time::Now();
  base::TimeDelta active_time = base::Minutes(5);
  registry().OnAppActive(kApp1, app1_instance_id, app1_start_time);
  task_environment()->FastForwardBy(active_time / 2);
  EXPECT_EQ(active_time / 2, registry().GetActiveTime(kApp1));
  EXPECT_TRUE(registry().IsAppActive(kApp1));

  task_environment()->FastForwardBy(active_time / 2);
  base::Time app1_end_time = base::Time::Now();
  registry().OnAppInactive(kApp1, app1_instance_id, app1_end_time);
  EXPECT_EQ(active_time, registry().GetActiveTime(kApp1));
  EXPECT_FALSE(registry().IsAppActive(kApp1));
}

TEST_F(AppActivityRegistryTest, MultipleWindowSameApp) {
  auto app2_instance_id1 = CreateInstanceIdForApp(kApp2);
  auto app2_instance_id2 = CreateInstanceIdForApp(kApp2);

  base::TimeDelta app2_active_time = base::Minutes(5);

  registry().OnAppActive(kApp2, app2_instance_id1, base::Time::Now());
  task_environment()->FastForwardBy(app2_active_time / 2);

  registry().OnAppActive(kApp2, app2_instance_id2, base::Time::Now());
  registry().OnAppInactive(kApp2, app2_instance_id1, base::Time::Now());
  registry().OnAppInactive(kApp2, app2_instance_id1, base::Time::Now());
  EXPECT_TRUE(registry().IsAppActive(kApp2));

  task_environment()->FastForwardBy(app2_active_time / 2);

  // Repeated calls to OnAppInactive shouldn't affect the time calculation.
  registry().OnAppInactive(kApp2, app2_instance_id1, base::Time::Now());

  // Mark the application inactive.
  registry().OnAppInactive(kApp2, app2_instance_id2, base::Time::Now());

  // There was no interruption in active times. Therefore, the app should
  // be active for the whole 5 minutes.
  EXPECT_EQ(app2_active_time, registry().GetActiveTime(kApp2));

  base::TimeDelta app2_inactive_time = base::Minutes(1);

  registry().OnAppActive(kApp2, app2_instance_id1, base::Time::Now());
  task_environment()->FastForwardBy(app2_active_time / 2);

  registry().OnAppInactive(kApp2, app2_instance_id1, base::Time::Now());
  task_environment()->FastForwardBy(app2_inactive_time);
  EXPECT_FALSE(registry().IsAppActive(kApp2));

  registry().OnAppActive(kApp2, app2_instance_id2, base::Time::Now());
  task_environment()->FastForwardBy(app2_active_time / 2);

  registry().OnAppInactive(kApp2, app2_instance_id1, base::Time::Now());
  EXPECT_TRUE(registry().IsAppActive(kApp2));

  registry().OnAppInactive(kApp2, app2_instance_id2, base::Time::Now());
  EXPECT_FALSE(registry().IsAppActive(kApp2));

  EXPECT_EQ(app2_active_time * 2, registry().GetActiveTime(kApp2));
}

TEST_F(AppActivityRegistryTest, AppTimeLimitReachedActiveApp) {
  base::Time start = base::Time::Now();

  // Set the time limit for kApp1 to be 10 minutes.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(10), start);
  SetAppLimit(kApp1, limit);

  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kAvailable);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);

  registry().OnAppActive(kApp1, app1_instance_id, start);

  // Expect 5 minute left notification.
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kFiveMinutes))
      .Times(1);
  task_environment()->FastForwardBy(base::Minutes(5));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_TRUE(registry().IsAppActive(kApp1));

  // Expect One minute left notification.
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kOneMinute))
      .Times(1);
  task_environment()->FastForwardBy(base::Minutes(4));
  EXPECT_EQ(base::Minutes(9), registry().GetActiveTime(kApp1));

  // Expect time limit reached notification.
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kTimeLimitReached))
      .Times(1);
  task_environment()->FastForwardBy(base::Minutes(1));
  EXPECT_EQ(base::Minutes(10), registry().GetActiveTime(kApp1));

  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kLimitReached);
}

TEST_F(AppActivityRegistryTest, SkippedFiveMinuteNotification) {
  // The application is inactive when the time limit is reached.
  base::Time start = base::Time::Now();

  // Set the time limit for kApp1 to be 25 minutes.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(25), start);
  SetAppLimit(kApp1, limit);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  base::TimeDelta active_time = base::Minutes(10);
  registry().OnAppActive(kApp1, app1_instance_id, start);

  task_environment()->FastForwardBy(active_time);

  const AppLimit new_limit(AppRestriction::kTimeLimit, base::Minutes(14),
                           start + active_time);
  SetAppLimit(kApp1, new_limit);

  // Notice that the 5 minute notification is jumped.
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kOneMinute))
      .Times(1);
  task_environment()->FastForwardBy(base::Minutes(3));
}

TEST_F(AppActivityRegistryTest, SkippedAllNotifications) {
  // The application is inactive when the time limit is reached.
  base::Time start = base::Time::Now();

  // Set the time limit for kApp1 to be 25 minutes.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(25), start);
  SetAppLimit(kApp1, limit);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  base::TimeDelta active_time = base::Minutes(10);
  registry().OnAppActive(kApp1, app1_instance_id, start);

  task_environment()->FastForwardBy(active_time);

  // Notice that the 5 minute and 1 minute notifications are jumped.
  const AppLimit new_limit(AppRestriction::kTimeLimit, base::Minutes(5),
                           start + active_time);
  SetAppLimit(kApp1, new_limit);

  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kLimitReached);
}

TEST_F(AppActivityRegistryTest, BlockedAppSetAvailable) {
  base::Time start = base::Time::Now();

  const base::TimeDelta kTenMinutes = base::Minutes(10);
  const AppLimit limit(AppRestriction::kTimeLimit, kTenMinutes, start);
  SetAppLimit(kApp1, limit);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  registry().OnAppActive(kApp1, app1_instance_id, start);

  // There are going to be a bunch of mock notification calls for kFiveMinutes,
  // kOneMinute, and kTimeLimitReached. They have already been tested in the
  // other tests. Let's igonre them.
  task_environment()->FastForwardBy(kTenMinutes);

  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kLimitReached);

  const AppLimit new_limit(AppRestriction::kTimeLimit, base::Minutes(20),
                           start + kTenMinutes);
  SetAppLimit(kApp1, new_limit);
  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kAvailable);
}

TEST_F(AppActivityRegistryTest, ResetTimeReached) {
  base::Time start = base::Time::Now();
  const base::TimeDelta kTenMinutes = base::Minutes(10);

  const AppLimit limit1(AppRestriction::kTimeLimit, kTenMinutes, start);
  const AppLimit limit2(AppRestriction::kTimeLimit, base::Minutes(20), start);
  const std::map<AppId, AppLimit> limits{{kApp1, limit1},
                                         {GetChromeAppId(), limit2}};
  registry().UpdateAppLimits(limits);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  auto app2_instance_id = CreateInstanceIdForApp(kApp2);
  registry().OnAppActive(kApp1, app1_instance_id, start);
  registry().OnAppActive(kApp2, app2_instance_id, start);

  task_environment()->FastForwardBy(kTenMinutes);

  // App 1's time limit has been reached.
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(kTenMinutes, registry().GetActiveTime(kApp1));

  // App 2 is still active.
  EXPECT_FALSE(registry().IsAppTimeLimitReached(kApp2));
  EXPECT_EQ(kTenMinutes, registry().GetActiveTime(kApp2));

  // Reset time has been reached.
  registry().OnResetTimeReached(start + kTenMinutes);
  EXPECT_FALSE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(base::Seconds(0), registry().GetActiveTime(kApp1));
  EXPECT_FALSE(registry().IsAppTimeLimitReached(kApp2));
  EXPECT_EQ(base::Seconds(0), registry().GetActiveTime(kApp2));

  // Now make sure that the timers have been scheduled appropriately.
  registry().OnAppActive(kApp1, app1_instance_id, start);

  task_environment()->FastForwardBy(kTenMinutes);

  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(kTenMinutes, registry().GetActiveTime(kApp1));

  // App 2 is still active.
  EXPECT_FALSE(registry().IsAppTimeLimitReached(kApp2));
  EXPECT_EQ(kTenMinutes, registry().GetActiveTime(kApp2));

  // Now let's make sure
  task_environment()->FastForwardBy(kTenMinutes);
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp2));
  EXPECT_EQ(*limit2.daily_limit(), registry().GetActiveTime(kApp2));
}

TEST_F(AppActivityRegistryTest, SharedTimeLimitForChromeAndWebApps) {
  base::Time start = base::Time::Now();
  const base::TimeDelta kOneHour = base::Hours(1);
  const base::TimeDelta kHalfHour = base::Minutes(30);

  const AppId kChromeAppId = GetChromeAppId();

  const AppLimit limit1(AppRestriction::kTimeLimit, kOneHour, start);
  const std::map<AppId, AppLimit> limits{{kChromeAppId, limit1}};

  registry().UpdateAppLimits(limits);

  auto app2_instance_id = CreateInstanceIdForApp(kApp2);

  // Make chrome active for 30 minutes.
  registry().OnChromeAppActivityChanged(ChromeAppActivityState::kActive, start);
  task_environment()->FastForwardBy(kHalfHour);
  registry().OnChromeAppActivityChanged(ChromeAppActivityState::kInactive,
                                        start + kHalfHour);

  // Expect that the active running time for app2 has been updated.
  EXPECT_EQ(kHalfHour, registry().GetActiveTime(kChromeAppId));
  EXPECT_EQ(kHalfHour, registry().GetActiveTime(kApp2));

  // Make |kApp2| active for 30 minutes. Expect that it reaches its time limit.
  registry().OnAppActive(kApp2, app2_instance_id, start + kHalfHour);
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp2, testing::_,
                                           AppNotification::kFiveMinutes))
      .Times(1);
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp2, testing::_,
                                           AppNotification::kOneMinute))
      .Times(1);
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp2, testing::_,
                                           AppNotification::kTimeLimitReached))
      .Times(1);

  task_environment()->FastForwardBy(kHalfHour);

  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp2));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kChromeAppId));
}

TEST_F(AppActivityRegistryTest, LimitChangedForActiveApp) {
  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kAvailable);

  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  base::Time start = base::Time::Now();
  registry().OnAppActive(kApp1, app1_instance_id, start);

  EXPECT_TRUE(registry().IsAppActive(kApp1));
  EXPECT_EQ(base::Minutes(0), registry().GetActiveTime(kApp1));
  EXPECT_EQ(std::nullopt, registry_test().GetAppLimit(kApp1));
  EXPECT_EQ(std::nullopt, registry().GetTimeLimit(kApp1));
  EXPECT_EQ(std::nullopt, registry_test().GetTimeLeft(kApp1));

  task_environment()->FastForwardBy(base::Minutes(5));

  // Limit set for active app.
  const AppLimit limit1(AppRestriction::kTimeLimit, base::Minutes(11),
                        base::Time::Now());
  SetAppLimit(kApp1, limit1);

  EXPECT_TRUE(registry().IsAppActive(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(11), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(6), registry_test().GetTimeLeft(kApp1));

  task_environment()->FastForwardBy(base::Minutes(5));

  EXPECT_TRUE(registry().IsAppActive(kApp1));
  EXPECT_EQ(base::Minutes(10), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(11), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(1), registry_test().GetTimeLeft(kApp1));

  // Increase the limit.
  const AppLimit limit_increase(AppRestriction::kTimeLimit, base::Minutes(20),
                                base::Time::Now());
  SetAppLimit(kApp1, limit_increase);
  EXPECT_TRUE(registry().IsAppActive(kApp1));
  EXPECT_EQ(base::Minutes(10), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(20), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(10), registry_test().GetTimeLeft(kApp1));

  // Decrease the limit.
  const AppLimit limit_decrease(AppRestriction::kTimeLimit, base::Minutes(5),
                                base::Time::Now());
  SetAppLimit(kApp1, limit_decrease);
  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(base::Minutes(10), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(5), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(0), registry_test().GetTimeLeft(kApp1));
}

TEST_F(AppActivityRegistryTest, LimitChangesForInactiveApp) {
  // Set initial limit.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(5),
                       base::Time::Now());
  SetAppLimit(kApp1, limit);

  // Use available limit - app should become paused.
  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  registry().OnAppActive(kApp1, app1_instance_id, base::Time::Now());
  task_environment()->FastForwardBy(base::Minutes(5));

  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(5), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(0), registry_test().GetTimeLeft(kApp1));

  // Decrease limit - app should remain paused.
  const AppLimit decreased_limit(AppRestriction::kTimeLimit, base::Minutes(3),
                                 base::Time::Now());
  SetAppLimit(kApp1, decreased_limit);

  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(3), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(0), registry_test().GetTimeLeft(kApp1));

  // Increase limit - app should become available, but inactive.
  const AppLimit increased_limit(AppRestriction::kTimeLimit, base::Minutes(10),
                                 base::Time::Now());
  SetAppLimit(kApp1, increased_limit);

  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppAvailable(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(10), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(5), registry_test().GetTimeLeft(kApp1));

  // Decrease limit above used time - app should stay available.
  const AppLimit limit_above_used(AppRestriction::kTimeLimit, base::Minutes(8),
                                  base::Time::Now());
  SetAppLimit(kApp1, limit_above_used);

  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppAvailable(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(8), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(3), registry_test().GetTimeLeft(kApp1));

  // Decrease limit below below time - app should become unavailabe.
  const AppLimit limit_below_used(AppRestriction::kTimeLimit, base::Minutes(4),
                                  base::Time::Now());
  SetAppLimit(kApp1, limit_below_used);

  EXPECT_FALSE(registry().IsAppActive(kApp1));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_EQ(base::Minutes(5), registry().GetActiveTime(kApp1));
  EXPECT_EQ(base::Minutes(4), *registry().GetTimeLimit(kApp1));
  EXPECT_EQ(base::Minutes(0), *registry_test().GetTimeLeft(kApp1));
}

TEST_F(AppActivityRegistryTest, RemoveLimitsFromAllowlistedApps) {
  // Set initial limit.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(5),
                       base::Time::Now());
  SetAppLimit(kApp1, limit);
  SetAppLimit(kApp2, limit);

  AppTimeLimitsAllowlistPolicyBuilder builder;
  builder.SetUp();
  builder.AppendToAllowlistAppList(kApp1);

  AppTimeLimitsAllowlistPolicyWrapper wrapper(&builder.dict());
  registry().OnTimeLimitAllowlistChanged(wrapper);

  EXPECT_FALSE(registry_test().GetAppLimit(kApp1));
  EXPECT_EQ(limit.daily_limit(), *registry().GetTimeLimit(kApp2));
  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kAlwaysAvailable);
}

TEST_F(AppActivityRegistryTest, AllowlistedAppsNoLimits) {
  AppTimeLimitsAllowlistPolicyBuilder builder;
  builder.SetUp();
  builder.AppendToAllowlistAppList(kApp1);
  AppTimeLimitsAllowlistPolicyWrapper wrapper(&builder.dict());
  registry().OnTimeLimitAllowlistChanged(wrapper);

  // Set initial limit.
  const AppLimit limit(AppRestriction::kTimeLimit, base::Minutes(5),
                       base::Time::Now());
  SetAppLimit(kApp1, limit);
  SetAppLimit(kApp2, limit);

  EXPECT_FALSE(registry_test().GetAppLimit(kApp1));
  EXPECT_EQ(limit.daily_limit(), *registry().GetTimeLimit(kApp2));
  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kAlwaysAvailable);
}

TEST_F(AppActivityRegistryTest, RestoredApplicationInformation) {
  auto app1_instance_id = CreateInstanceIdForApp(kApp1);
  base::TimeDelta active_timedelta = base::Minutes(30);

  const AppLimit limit(AppRestriction::kTimeLimit, active_timedelta,
                       base::Time::Now());
  SetAppLimit(kApp1, limit);

  base::Time app1_start_time_1 = base::Time::Now();
  registry().OnAppActive(kApp1, app1_instance_id, app1_start_time_1);
  task_environment()->FastForwardBy(active_timedelta / 2);

  // Save app activity.
  registry_test().SaveAppActivity();

  base::Time app1_inactive_time_1 = base::Time::Now();
  registry().OnAppInactive(kApp1, app1_instance_id, app1_inactive_time_1);

  // App1 is inactive for 5 minutes.
  task_environment()->FastForwardBy(base::Minutes(5));

  base::Time app1_start_time_2 = base::Time::Now();
  registry().OnAppActive(kApp1, app1_instance_id, app1_start_time_2);
  task_environment()->FastForwardBy(active_timedelta / 2);

  // Time limit is reached. App becomes inactive.
  EXPECT_FALSE(registry().IsAppActive(kApp1));
  base::Time app1_inactive_time_2 = base::Time::Now();

  // Save app activity.
  registry_test().SaveAppActivity();

  // Now let's recreate AppActivityRegistry. Its state should be restored.
  ReInitializeRegistry();

  EXPECT_TRUE(registry().IsAppInstalled(kApp1));
  EXPECT_TRUE(registry().IsAppInstalled(kApp2));
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));
  EXPECT_TRUE(registry().IsAppAvailable(kApp2));
  EXPECT_EQ(registry().GetActiveTime(kApp1), active_timedelta);

  // Now let's test that the app activity are stored appropriately.
  const base::Value::List& list =
      prefs()->GetList(prefs::kPerAppTimeLimitsAppActivities);

  const std::vector<PersistedAppInfo> app_infos =
      PersistedAppInfo::PersistedAppInfosFromList(
          list,
          /* include_app_activity_array */ true);

  // 3 applications. kApp1, kApp2 and Chrome browser.
  EXPECT_TRUE(app_infos.size() == 3);
  std::vector<AppActivity::ActiveTime> app1_times = {{
      AppActivity::ActiveTime(app1_start_time_1, app1_inactive_time_1),
      AppActivity::ActiveTime(app1_start_time_2, app1_inactive_time_2),
  }};

  for (const auto& app_info : app_infos) {
    if (app_info.app_id() == kApp1) {
      const std::vector<AppActivity::ActiveTime> active_time =
          app_info.active_times();
      EXPECT_EQ(app1_times.size(), active_time.size());
      for (size_t i = 0; i < app1_times.size(); i++) {
        EXPECT_EQ(app1_times[i], active_time[i]);
      }

    } else {
      EXPECT_TRUE(app_info.active_times().size() == 0);
    }
  }
}

TEST_F(AppActivityRegistryTest, RemoveUninstalledApplications) {
  CreateAppActivityForApp(kApp1, base::Hours(1));
  CreateAppActivityForApp(kApp2, base::Hours(1));

  // App1 has been uninstalled.
  registry().OnAppUninstalled(kApp1);
  task_environment()->FastForwardBy(base::Minutes(10));

  // Removes kApp1 and cleans up ActiveTimes list in user pref.
  registry().OnSuccessfullyReported(base::Time::Now());

  // Now let's test that the app activity are stored appropriately.
  const base::Value::List& list =
      prefs()->GetList(prefs::kPerAppTimeLimitsAppActivities);

  const std::vector<PersistedAppInfo> app_infos =
      PersistedAppInfo::PersistedAppInfosFromList(
          list,
          /* include_app_activity_array */ true);

  EXPECT_EQ(app_infos.size(), 3u);
  for (const auto& entry : app_infos)
    EXPECT_EQ(entry.active_times().size(), 0u);

  // kApp1 will still be present since it still has activity.
  registry().OnResetTimeReached(base::Time::Now());
  registry().SaveAppActivity();
  registry().OnSuccessfullyReported(base::Time::Now());

  const base::Value::List& new_list =
      prefs()->GetList(prefs::kPerAppTimeLimitsAppActivities);

  const std::vector<PersistedAppInfo> final_app_infos =
      PersistedAppInfo::PersistedAppInfosFromList(
          new_list,
          /* include_app_activity_array */ false);

  // Two apps left. They are Chrome, and kApp2.
  EXPECT_EQ(final_app_infos.size(), 2u);
  for (const auto& entry : final_app_infos) {
    EXPECT_NE(entry.app_id(), kApp1);
  }
}

TEST_F(AppActivityRegistryTest, RemoveOldEntries) {
  base::Time start_time = base::Time::Now();

  CreateAppActivityForApp(kApp1, base::Hours(1));
  CreateAppActivityForApp(kApp2, base::Hours(1));

  prefs()->SetInt64(prefs::kPerAppTimeLimitsLastSuccessfulReportTime,
                    start_time.ToDeltaSinceWindowsEpoch().InMicroseconds());

  task_environment()->AdvanceClock(base::Days(30));
  task_environment()->RunUntilIdle();

  // Now let's recreate AppActivityRegistry. Its state should be restored.
  ReInitializeRegistry();

  // Now let's test that the app activity are stored appropriately.
  const base::Value::List& list =
      prefs()->GetList(prefs::kPerAppTimeLimitsAppActivities);

  const std::vector<PersistedAppInfo> app_infos =
      PersistedAppInfo::PersistedAppInfosFromList(
          list,
          /* include_app_activity_array */ true);

  // The app activities have been cleared.
  for (const auto& app_info : app_infos) {
    const std::vector<AppActivity::ActiveTime>& active_time =
        app_info.active_times();
    EXPECT_EQ(active_time.size(), 0u);
  }
}

TEST_F(AppActivityRegistryTest, ActiveWebAppBlocked) {
  // Create activity for web app.
  CreateAppActivityForApp(kApp2, base::Hours(1));

  // Set Chrome as active.
  registry().OnChromeAppActivityChanged(ChromeAppActivityState::kActive,
                                        base::Time::Now());

  // Update the time limits for Chrome.
  AppLimit chrome_limit(AppRestriction::kTimeLimit, base::Minutes(30),
                        base::Time::Now());

  std::map<AppId, AppLimit> app_limits = {{GetChromeAppId(), chrome_limit}};
  registry().UpdateAppLimits(app_limits);

  // Web time limit should be reached.
  EXPECT_EQ(registry().GetAppState(kApp2), AppState::kLimitReached);

  EXPECT_EQ(registry().GetAppState(GetChromeAppId()), AppState::kLimitReached);
}

TEST_F(AppActivityRegistryTest, OverrideLimitReachedState) {
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);
  const base::TimeDelta limit = base::Minutes(30);

  std::map<AppId, AppLimit> app_limits = {
      {kApp1, AppLimit(AppRestriction::kTimeLimit, limit, base::Time::Now())},
      {GetChromeAppId(),
       AppLimit(AppRestriction::kTimeLimit, limit, base::Time::Now())}};

  registry().UpdateAppLimits(app_limits);

  // Save app activity and reinitialize.
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Minutes(30),
                                                     /* was_active */ true))
      .Times(1);
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp2, base::Minutes(30),
                                                     /* was_active */ true))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(GetChromeAppId(), base::Minutes(30),
                                /* was_active */ false))
      .Times(1);

  // App limits will be reached.
  CreateAppActivityForApp(kApp1, 2 * limit);
  CreateAppActivityForApp(kApp2, 2 * limit);

  // Save app activity and reinitialize.
  registry().SaveAppActivity();
  ReInitializeRegistry();
  registry().AddAppStateObserver(&state_observer_mock);
  registry().UpdateAppLimits(app_limits);

  // When OnAppInstalled is called for AppActivityRegistry, it will notify its
  // app state observers that the app time limit has been reached.
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Minutes(30),
                                                     /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp2, base::Minutes(30),
                                                     /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(GetChromeAppId(), base::Minutes(30),
                                /* was_active */ false))
      .Times(1);
  InstallApps();

  EXPECT_EQ(registry().GetAppState(kApp1), AppState::kLimitReached);
  EXPECT_EQ(registry().GetAppState(kApp2), AppState::kLimitReached);
  EXPECT_EQ(registry().GetAppState(GetChromeAppId()), AppState::kLimitReached);

  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Minutes(30),
                                                     /* was_active */ true))
      .Times(1);
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp2, base::Minutes(30),
                                                     /* was_active */ true))
      .Times(1);

  registry().OnAppActive(kApp1, GetInstanceIdForApp(kApp1), base::Time::Now());
  registry().OnAppActive(kApp2, GetInstanceIdForApp(kApp2), base::Time::Now());
}

TEST_F(AppActivityRegistryTest, AvoidReduntantNotifications) {
  const base::TimeDelta delta = base::Minutes(5);
  AppLimit chrome_limit(AppRestriction::kTimeLimit, base::Minutes(30),
                        base::Time::Now());
  AppLimit app1_limit(AppRestriction::kTimeLimit, base::Minutes(5),
                      base::Time::Now() + delta);
  std::map<AppId, AppLimit> app_limits = {{GetChromeAppId(), chrome_limit},
                                          {kApp1, app1_limit}};
  EXPECT_CALL(
      notification_delegate_mock(),
      ShowAppTimeLimitNotification(GetChromeAppId(), chrome_limit.daily_limit(),
                                   AppNotification::kTimeLimitChanged))
      .Times(1);

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, app1_limit.daily_limit(),
                                           AppNotification::kTimeLimitChanged))
      .Times(1);

  registry().UpdateAppLimits(app_limits);
  registry().SaveAppActivity();

  // Reinitialized the registry. We don't expect redundant time limit updatese
  // will result in notifications.
  ReInitializeRegistry();
  registry().OnAppInstalled(GetChromeAppId());
  registry().OnAppInstalled(kApp1);
  registry().OnAppInstalled(kApp2);

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(GetChromeAppId(), testing::_,
                                           AppNotification::kTimeLimitChanged))
      .Times(0);
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kTimeLimitChanged))
      .Times(0);

  registry().UpdateAppLimits(app_limits);

  // Update the limit for Chrome.
  AppLimit new_chrome_limit(AppRestriction::kTimeLimit, base::Minutes(15),
                            base::Time::Now() + 2 * delta);
  app_limits.at(GetChromeAppId()) = new_chrome_limit;

  // Expect that there will be a notification for Chrome but not for kApp1.
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(GetChromeAppId(),
                                           new_chrome_limit.daily_limit(),
                                           AppNotification::kTimeLimitChanged))
      .Times(1);
  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kTimeLimitChanged))
      .Times(0);
  registry().UpdateAppLimits(app_limits);
}

TEST_F(AppActivityRegistryTest, NoNotification) {
  AppLimit app1_limit(AppRestriction::kTimeLimit, base::Minutes(30),
                      base::Time::Now());
  std::map<AppId, AppLimit> app_limits = {{kApp1, app1_limit}};

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, app1_limit.daily_limit(),
                                           AppNotification::kTimeLimitChanged))
      .Times(0);
  registry().SaveAppActivity();
  ReInitializeRegistry();
  registry().UpdateAppLimits(app_limits);
}

TEST_F(AppActivityRegistryTest, NotificationAfterAppInstall) {
  AppLimit app1_limit(AppRestriction::kTimeLimit, base::Minutes(30),
                      base::Time::Now());
  std::map<AppId, AppLimit> app_limits = {{kApp1, app1_limit}};

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, app1_limit.daily_limit(),
                                           AppNotification::kTimeLimitChanged))
      .Times(1);

  registry().SaveAppActivity();
  ReInitializeRegistry();
  registry().UpdateAppLimits(app_limits);
  registry().OnAppInstalled(kApp1);
}

TEST_F(AppActivityRegistryTest, AvoidRedundantCallsToPauseApp) {
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);

  const base::TimeDelta kOneHour = base::Hours(1);
  registry().SetAppLimit(
      kApp1, AppLimit(AppRestriction::kTimeLimit, kOneHour, base::Time::Now()));

  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Hours(1),
                                                     /* was_active */ true))
      .Times(1);
  CreateAppActivityForApp(kApp1, kOneHour);
  EXPECT_TRUE(registry().IsAppTimeLimitReached(kApp1));

  auto app1_instance_id = GetInstanceIdForApp(kApp1);
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Hours(1),
                                                     /* was_active */ true))
      .Times(0);
  registry().OnAppActive(kApp1, app1_instance_id, base::Time::Now());

  auto new_app1_instance_id = CreateInstanceIdForApp(kApp1);
  EXPECT_CALL(state_observer_mock, OnAppLimitReached(kApp1, base::Hours(1),
                                                     /* was_active */ true))
      .Times(1);
  registry().OnAppActive(kApp1, new_app1_instance_id, base::Time::Now());

  registry().OnAppDestroyed(kApp1, new_app1_instance_id, base::Time::Now());
}

TEST_F(AppActivityRegistryTest, AppReinstallations) {
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);

  AppLimit app1_limit(AppRestriction::kTimeLimit, base::Hours(1),
                      base::Time::Now());

  SetAppLimit(kApp1, app1_limit);

  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp1, app1_limit.daily_limit().value(),
                                /* was_active */ true))
      .Times(1);

  // Application will reach its time limits.
  CreateAppActivityForApp(kApp1, base::Hours(2));
  registry().OnAppUninstalled(kApp1);
  registry().SaveAppActivity();

  // Now let's reinstantiate the registry.
  ReInitializeRegistry();
  registry().AddAppStateObserver(&state_observer_mock);

  EXPECT_CALL(state_observer_mock, OnAppInstalled(kApp1)).Times(1);

  // The child user reinstalls the application.
  registry().OnAppInstalled(kApp1);
  registry().OnAppAvailable(kApp1);

  // Let's set the time limit.
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp1, app1_limit.daily_limit().value(),
                                /* was_active */ false))
      .Times(1);
  registry().SetAppLimit(kApp1, app1_limit);

  // Reinstalled within the same session.
  registry().OnAppUninstalled(kApp1);
  EXPECT_CALL(state_observer_mock, OnAppInstalled(kApp1)).Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp1, app1_limit.daily_limit().value(),
                                /* was_active */ false))
      .Times(1);

  registry().OnAppAvailable(kApp1);
}

TEST_F(AppActivityRegistryTest, LimitSetAfterActivity) {
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);

  const AppId kApp3(apps::AppType::kWeb, "l");
  registry().OnAppInstalled(kApp3);
  registry().OnAppAvailable(kApp3);

  CreateAppActivityForApp(kApp3, base::Hours(1));

  registry().OnAppActive(kApp3, CreateInstanceIdForApp(kApp3),
                         base::Time::Now());

  const AppLimit web_limit(AppRestriction::kTimeLimit, base::Minutes(20),
                           base::Time::Now());
  EXPECT_CALL(
      state_observer_mock,
      OnAppLimitReached(GetChromeAppId(), web_limit.daily_limit().value(),
                        /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp2, web_limit.daily_limit().value(),
                                /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp3, web_limit.daily_limit().value(),
                                /* was_active */ true))
      .Times(1);
  const std::map<AppId, AppLimit> limits{{GetChromeAppId(), web_limit}};
  registry().UpdateAppLimits(limits);
}

TEST_F(AppActivityRegistryTest, WebAppInstalled) {
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);
  const AppLimit web_limit(AppRestriction::kTimeLimit, base::Hours(2),
                           base::Time::Now());
  const std::map<AppId, AppLimit> limits{{GetChromeAppId(), web_limit}};
  registry().UpdateAppLimits(limits);

  registry().OnAppActive(kApp2, CreateInstanceIdForApp(kApp2),
                         base::Time::Now());
  task_environment()->FastForwardBy(base::Hours(1));

  // Now a new application is installed.
  const AppId kApp3(apps::AppType::kWeb, "l");

  registry().OnAppInstalled(kApp3);
  registry().OnAppAvailable(kApp3);

  EXPECT_CALL(
      state_observer_mock,
      OnAppLimitReached(GetChromeAppId(), web_limit.daily_limit().value(),
                        /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp2, web_limit.daily_limit().value(),
                                /* was_active */ true))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp3, web_limit.daily_limit().value(),
                                /* was_active */ false))
      .Times(1);
  task_environment()->FastForwardBy(base::Hours(1));
}

TEST_F(AppActivityRegistryTest, AppBlocked) {
  const AppLimit app1_limit(AppRestriction::kBlocked, std::nullopt,
                            base::Time::Now());
  const std::map<AppId, AppLimit> limits{{kApp1, app1_limit}};

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kBlocked))
      .Times(1);
  registry().UpdateAppLimits(limits);

  EXPECT_CALL(notification_delegate_mock(),
              ShowAppTimeLimitNotification(kApp1, testing::_,
                                           AppNotification::kAvailable))
      .Times(1);

  registry().UpdateAppLimits(std::map<AppId, AppLimit>());
}

TEST_F(AppActivityRegistryTest, GoogleSlidesPaused) {
  registry().OnAppInstalled(kGoogleSlidesApp);
  registry().OnAppAvailable(kGoogleSlidesApp);
  AppStateObserverMock state_observer_mock;
  registry().AddAppStateObserver(&state_observer_mock);
  const AppLimit web_limit(AppRestriction::kTimeLimit, base::Hours(2),
                           base::Time::Now());
  const std::map<AppId, AppLimit> limits{{GetChromeAppId(), web_limit}};
  registry().UpdateAppLimits(limits);
  EXPECT_EQ(registry().GetTimeLimit(kGoogleSlidesApp), web_limit.daily_limit());

  EXPECT_CALL(
      state_observer_mock,
      OnAppLimitReached(GetChromeAppId(), web_limit.daily_limit().value(),
                        /* was_active */ false))
      .Times(1);
  EXPECT_CALL(state_observer_mock,
              OnAppLimitReached(kApp2, web_limit.daily_limit().value(),
                                /* was_active */ false))
      .Times(1);
  EXPECT_CALL(
      state_observer_mock,
      OnAppLimitReached(kGoogleSlidesApp, web_limit.daily_limit().value(),
                        /* was_active */ true))
      .Times(1);

  CreateAppActivityForApp(kApp2, base::Hours(1));
  CreateAppActivityForApp(kGoogleSlidesApp, base::Hours(1));
}

}  // namespace app_time
}  // namespace ash