// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CHROME_BROWSER_ASH_CHILD_ACCOUNTS_TIME_LIMITS_APP_ACTIVITY_REGISTRY_H_
#define CHROME_BROWSER_ASH_CHILD_ACCOUNTS_TIME_LIMITS_APP_ACTIVITY_REGISTRY_H_

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

#include "base/memory/raw_ptr.h"
#include "base/observer_list_types.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_activity_report_interface.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_service_wrapper.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_types.h"

namespace base {
class UnguessableToken;
}  // namespace base

namespace enterprise_management {
class ChildStatusReportRequest;
}  // namespace enterprise_management

class PrefRegistrySimple;
class PrefService;

namespace ash {
namespace app_time {

class AppTimeLimitsAllowlistPolicyWrapper;
class AppTimeNotificationDelegate;
class PersistedAppInfo;

// Keeps track of app activity and time limits information.
// Stores app activity between user session. Information about uninstalled apps
// are removed from the registry after activity was uploaded to server or after
// 30 days if upload did not happen.
class AppActivityRegistry : public AppServiceWrapper::EventListener {
 public:
  // Used for tests to get internal implementation details.
  class TestApi {
   public:
    explicit TestApi(AppActivityRegistry* registry);
    ~TestApi();

    const std::optional<AppLimit>& GetAppLimit(const AppId& app_id) const;
    std::optional<base::TimeDelta> GetTimeLeft(const AppId& app_id) const;
    void SaveAppActivity();

   private:
    const raw_ptr<AppActivityRegistry, DanglingUntriaged> registry_;
  };

  // Interface for the observers interested in the changes of apps state.
  class AppStateObserver : public base::CheckedObserver {
   public:
    AppStateObserver() = default;
    AppStateObserver(const AppStateObserver&) = delete;
    AppStateObserver& operator=(const AppStateObserver&) = delete;
    ~AppStateObserver() override = default;

    // Called when state of the app with |app_id| changed to |kLimitReached|.
    // |was_active| indicates whether the app was active before reaching the
    // limit.
    virtual void OnAppLimitReached(const AppId& app_id,
                                   base::TimeDelta time_limit,
                                   bool was_active) = 0;

    // Called when state of the app with |app_id| is no longer |kLimitReached|.
    virtual void OnAppLimitRemoved(const AppId& app_id) = 0;

    // Called when new app was installed.
    virtual void OnAppInstalled(const AppId& app_id) = 0;
  };

  static void RegisterProfilePrefs(PrefRegistrySimple* registry);

  AppActivityRegistry(AppServiceWrapper* app_service_wrapper,
                      AppTimeNotificationDelegate* notification_delegate,
                      PrefService* pref_service);
  AppActivityRegistry(const AppActivityRegistry&) = delete;
  AppActivityRegistry& operator=(const AppActivityRegistry&) = delete;
  ~AppActivityRegistry() override;

  // AppServiceWrapper::EventListener:
  void OnAppInstalled(const AppId& app_id) override;
  void OnAppUninstalled(const AppId& app_id) override;
  void OnAppAvailable(const AppId& app_id) override;
  void OnAppBlocked(const AppId& app_id) override;
  void OnAppActive(const AppId& app_id,
                   const base::UnguessableToken& instance_id,
                   base::Time timestamp) override;
  void OnAppInactive(const AppId& app_id,
                     const base::UnguessableToken& instance_id,
                     base::Time timestamp) override;
  void OnAppDestroyed(const AppId& app_id,
                      const base::UnguessableToken& instance_id,
                      base::Time timestamp) override;

  bool IsAppInstalled(const AppId& app_id) const;
  bool IsAppAvailable(const AppId& app_id) const;
  bool IsAppBlocked(const AppId& app_id) const;
  bool IsAppTimeLimitReached(const AppId& app_id) const;
  bool IsAppActive(const AppId& app_id) const;
  bool IsAllowlistedApp(const AppId& app_id) const;

  // Manages AppStateObservers.
  void AddAppStateObserver(AppStateObserver* observer);
  void RemoveAppStateObserver(AppStateObserver* observer);

  // Called from AppTimeController to notify AppActivityRegistry about installed
  // apps which AppActivityRegistry may have missed.
  void SetInstalledApps(const std::vector<AppId>& installed_apps);

  // Returns the total active time for the application since the last time limit
  // reset.
  base::TimeDelta GetActiveTime(const AppId& app_id) const;

  // Web time limit is the time limit set for Chrome browser. It is shared
  // between Chrome and Web apps.
  const std::optional<AppLimit>& GetWebTimeLimit() const;

  AppState GetAppState(const AppId& app_id) const;

  // Returns current time limit for the app identified by |app_id|.
  // Will return nullopt if there is no limit set.
  std::optional<base::TimeDelta> GetTimeLimit(const AppId& app_id) const;

  // Reporting enablement is set if |enabled| has value.
  void SetReportingEnabled(std::optional<bool> enabled);

  void GenerateHiddenApps(
      enterprise_management::ChildStatusReportRequest* report);

  // Populates |report| with collected app activity. Returns whether any data
  // were reported.
  AppActivityReportInterface::ReportParams GenerateAppActivityReport(
      enterprise_management::ChildStatusReportRequest* report);

  // Application activities earlier than |timestamp| have been reported. Clear
  // entries earlier than |timestamp|.
  void OnSuccessfullyReported(base::Time timestamp);

  // Updates time limits for all installed apps.
  // Apps not present in |app_limits| are treated as they do not have limit set.
  // Returns true if a new app limit is observed in any of the applications.
  bool UpdateAppLimits(const std::map<AppId, AppLimit>& app_limits);

  // Sets time limit for app identified with |app_id|.
  // Does not affect limits of any other app. Not specified |app_limit| means
  // that app does not have limit set. Does not affect limits of any other app.
  // Returns true if a new app limit is observed.
  bool SetAppLimit(const AppId& app_id,
                   const std::optional<AppLimit>& app_limit);

  // Sets the app identified with |app_id| as being always available.
  void SetAppAllowlisted(const AppId& app_id);

  // Reset time has been reached at |timestamp|.
  void OnResetTimeReached(base::Time timestamp);

  // Called from WebTimeActivityProvider to update chrome app state.
  void OnChromeAppActivityChanged(ChromeAppActivityState state,
                                  base::Time timestamp);

  // Allowlisted applications changed. Called by AppTimeController.
  void OnTimeLimitAllowlistChanged(
      const AppTimeLimitsAllowlistPolicyWrapper& wrapper);

  // Saves app activity into user preference.
  void SaveAppActivity();

  std::vector<AppId> GetAppsWithAppRestriction(
      AppRestriction restriction) const;

 private:
  struct SystemNotification {
    SystemNotification(std::optional<base::TimeDelta> app_time_limit,
                       AppNotification app_notification);
    SystemNotification(const SystemNotification&);
    SystemNotification& operator=(const SystemNotification&);
    std::optional<base::TimeDelta> time_limit = std::nullopt;
    AppNotification notification = AppNotification::kUnknown;
  };

  // Bundles detailed data stored for a specific app.
  struct AppDetails {
    AppDetails();
    explicit AppDetails(const AppActivity& activity);
    AppDetails(const AppDetails&) = delete;
    AppDetails& operator=(const AppDetails&) = delete;
    ~AppDetails();

    // Resets the time limit check timer.
    void ResetTimeCheck();

    // Checks |limit| and |activity| to determine if the limit was reached.
    bool IsLimitReached() const;

    // Checks if |limit| is equal to |another_limit| with exception for the
    // timestamp (that does not indicate that limit changed).
    bool IsLimitEqual(const std::optional<AppLimit>& another_limit) const;

    // Contains information about current app state and logged activity.
    AppActivity activity{AppState::kAvailable};

    // Contains the set of active instances for the application.
    std::set<base::UnguessableToken> active_instances;

    // The set of instances AppActivityRegistry has requested to be paused, but
    // which have not been paused yet.
    std::set<base::UnguessableToken> paused_instances;

    // Contains information about restriction set for the app.
    std::optional<AppLimit> limit;

    // Timer set up for when the app time limit is expected to be reached and
    // preceding notifications.
    std::unique_ptr<base::OneShotTimer> app_limit_timer;

    // Boolean to specify if OnAppInstalled call has been received for this
    // particular application.
    bool received_app_installed_ = false;

    // At the beginning of a session, we may want to send system notifications
    // for applications. This may happen if there is an update in
    // PerAppTimeLimits policy while the user was logged out. In these
    // scenarios, we have to wait until the application is installed.
    std::vector<SystemNotification> pending_notifications_;
  };

  // OnAppReinstalled is called when an application has been uninstalled and
  // then installed again before being removed from app registry.
  void OnAppReinstalled(const AppId& app_id);

  // Removes data older than |timestamp| from the registry.
  // Removes entries for uninstalled apps if there is no more relevant activity
  // data left.
  void CleanRegistry(base::Time timestamp);

  // Adds an ap to the registry if it does not exist.
  void Add(const AppId& app_id);

  // Convenience methods to access state of the app identified by |app_id|.
  // Should only be called if app exists in the registry.
  void SetAppState(const AppId& app_id, AppState app_state);

  // Notifies state observers the application identified by |app_id| has reached
  // its set time limit.
  void NotifyLimitReached(const AppId& app_id, bool was_active);

  // Methods to set the application as active and inactive respectively.
  void SetAppActive(const AppId& app_id, base::Time timestamp);
  void SetAppInactive(const AppId& app_id, base::Time timestamp);

  std::optional<base::TimeDelta> GetTimeLeftForApp(const AppId& app_id) const;

  // Schedules a time limit check for application when it becomes active.
  void ScheduleTimeLimitCheckForApp(const AppId& app_id);

  // Checks the limit and shows notification if needed.
  void CheckTimeLimitForApp(const AppId& app_id);

  // Shows notification about time limit updates for the app if there were
  // relevant changes between |old_limit| and |new_limit|. Returns true if a
  // notification has been made.
  bool ShowLimitUpdatedNotificationIfNeeded(
      const AppId& app_id,
      const std::optional<AppLimit>& old_limit,
      const std::optional<AppLimit>& new_limit);

  base::TimeDelta GetWebActiveRunningTime() const;

  void WebTimeLimitReached(base::Time timestamp);

  // Initializes |activity_registry_| from the stored values in user pref.
  // Installed applications, their AppStates and their running active times will
  // be restored.
  void InitializeRegistryFromPref();
  void InitializeAppActivities();

  // Updates |AppActivity::active_times_| to include the current activity up to
  // |timestamp| then creates the most up to date instance of PersistedAppInfo.
  PersistedAppInfo GetPersistedAppInfoForApp(const AppId& app_id,
                                             base::Time timestamp);

  // Returns true if the last successfully reported time is earlier than 30 days
  // from base::Time::Now();
  bool ShouldCleanUpStoredPref();

  // Sends system notification for the application.
  void SendSystemNotificationsForApp(const AppId& app_id);

  // Shows notification or queues it to be shown later.
  void MaybeShowSystemNotification(const AppId& app_id,
                                   const SystemNotification& notification);

  // Called by AppActivityRegistry::SetAppLimit after the application's limit
  // has been updated.
  void AppLimitUpdated(const AppId& app_id);

  const raw_ptr<PrefService> pref_service_;

  // Owned by AppTimeController.
  const raw_ptr<AppServiceWrapper> app_service_wrapper_;

  // Notification delegate.
  const raw_ptr<AppTimeNotificationDelegate> notification_delegate_;

  // Observers to be notified about app state changes.
  base::ObserverList<AppStateObserver> app_state_observers_;

  std::map<AppId, AppDetails> activity_registry_;

  // Newly installed applications which have not yet been added to the user
  // pref.
  std::vector<AppId> newly_installed_apps_;

  // Repeating timer to trigger saving app activity to pref service.
  base::RepeatingTimer save_data_to_pref_service_;

  // This records the timestamp of the latest set app limit.
  base::Time latest_app_limit_update_;

  // Boolean to capture if app activity data reporting is enabled.
  bool activity_reporting_enabled_ = true;
};

}  // namespace app_time
}  // namespace ash

#endif  // CHROME_BROWSER_ASH_CHILD_ACCOUNTS_TIME_LIMITS_APP_ACTIVITY_REGISTRY_H_