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

#ifndef CHROME_BROWSER_APPS_APP_SHIM_APP_SHIM_MANAGER_MAC_H_
#define CHROME_BROWSER_APPS_APP_SHIM_APP_SHIM_MANAGER_MAC_H_

#include <Security/Security.h>

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

#include "apps/app_lifetime_monitor.h"
#include "base/apple/scoped_cftyperef.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/apps/app_shim/app_shim_host_bootstrap_mac.h"
#include "chrome/browser/apps/app_shim/app_shim_host_mac.h"
#include "chrome/browser/badging/badge_manager.h"
#include "chrome/browser/profiles/avatar_menu_observer.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager_observer.h"
#include "chrome/browser/profiles/profile_observer.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_list_observer.h"
#include "chrome/common/mac/app_shim.mojom.h"
#include "chrome/services/mac_notifications/public/mojom/mac_notifications.mojom.h"
#include "components/webapps/common/web_app_id.h"

class Profile;
class ProfileManager;

namespace base {
class FilePath;
}  // namespace base

namespace content {
class BrowserContext;
}  // namespace content

namespace apps {

// The passed in `callback` will be called when all launches for the next app
// shim launch have completed (all profiles the app will launch in, as well
// as possibly multiple windows within profiles).
void SetMacShimStartupDoneCallbackForTesting(base::OnceClosure callback);

// Returns the callback set with SetMacShimStartupDoneCallbackForTesting;
base::OnceClosure TakeShimStartupDoneCallbackForTesting();

// This app shim handler that handles events for app shims that correspond to an
// extension.
class AppShimManager
    : public AppShimHostBootstrap::Client,
      public AppShimHost::Client,
      public AppLifetimeMonitor::Observer,
      public BrowserListObserver,
      public AvatarMenuObserver,
      public ProfileManagerObserver,
      public ProfileObserver,
      public mac_notifications::mojom::MacNotificationProvider,
      public mac_notifications::mojom::MacNotificationActionHandler {
 public:
  class Delegate {
   public:
    virtual ~Delegate() = default;

    // Show all app windows (for non-PWA apps). Return true if there existed any
    // windows.
    virtual bool ShowAppWindows(Profile* profile,
                                const webapps::AppId& app_id) = 0;

    // Close all app windows (for non-PWA apps).
    virtual void CloseAppWindows(Profile* profile,
                                 const webapps::AppId& app_id) = 0;

    // Return true iff |app_id| corresponds to an app that is installed for
    // |profile|. Note that |profile| may be nullptr (in which case it should
    // always return false).
    virtual bool AppIsInstalled(Profile* profile,
                                const webapps::AppId& app_id) = 0;

    // Return true iff the specified app can create an AppShimHost, which will
    // keep the app shim process connected (as opposed to, e.g, a bookmark app
    // that opens in a tab, which will immediately close).
    virtual bool AppCanCreateHost(Profile* profile,
                                  const webapps::AppId& app_id) = 0;

    // Return true if Cocoa windows for this app should be hosted in the app
    // shim process.
    virtual bool AppUsesRemoteCocoa(Profile* profile,
                                    const webapps::AppId& app_id) = 0;

    // Return true if a single app shim is used for all profiles (as opposed to
    // one shim per profile).
    virtual bool AppIsMultiProfile(Profile* profile,
                                   const webapps::AppId& app_id) = 0;

    // Open a dialog to enable the specified extension. Call |callback| after
    // the dialog is executed.
    virtual void EnableExtension(Profile* profile,
                                 const std::string& extension_id,
                                 base::OnceCallback<void()> callback) = 0;

    // Launch the app in Chrome. This will (often) create a new window. It is
    // guaranteed that |app_id| is installed for |profile| when this method
    // is called.
    virtual void LaunchApp(
        Profile* profile,
        const webapps::AppId& app_id,
        const std::vector<base::FilePath>& files,
        const std::vector<GURL>& urls,
        const GURL& override_url,
        chrome::mojom::AppShimLoginItemRestoreState login_item_restore_state,
        base::OnceClosure launch_finished_callback) = 0;

    // Launch the shim process for an app. It is guaranteed that |app_id| is
    // installed for |profile| when this method is called.
    virtual void LaunchShim(Profile* profile,
                            const webapps::AppId& app_id,
                            web_app::LaunchShimUpdateBehavior update_behavior,
                            web_app::ShimLaunchMode launch_mode,
                            ShimLaunchedCallback launched_callback,
                            ShimTerminatedCallback terminated_callback) = 0;

    // Return true if any app windows are open. This is eventually invoked
    // by MaybeTerminate. It does not apply to bookmark apps.
    virtual bool HasNonBookmarkAppWindowsOpen() = 0;

    virtual std::vector<chrome::mojom::ApplicationDockMenuItemPtr>
    GetAppShortcutsMenuItemInfos(Profile* profile,
                                 const webapps::AppId& app_id) = 0;
  };

  // Helper function to get the instance on the browser process. This will be
  // non-null except for tests.
  static AppShimManager* Get();

  explicit AppShimManager(std::unique_ptr<Delegate> delegate);
  AppShimManager(const AppShimManager&) = delete;
  AppShimManager& operator=(const AppShimManager&) = delete;
  ~AppShimManager() override;

  // Get the host corresponding to a profile and app id, or null if there is
  // none.
  AppShimHost* FindHost(Profile* profile, const webapps::AppId& app_id);

  // If the specified |browser| should be using RemoteCocoa (because it is a
  // bookmark app), then get or create an AppShimHost for it, and return
  // it. If an AppShimHost had to be created (e.g, because the app process is
  // still launching), create one, which will bind to the app process when it
  // finishes launching.
  AppShimHost* GetHostForRemoteCocoaBrowser(Browser* browser);

  // Returns true if the specified `browser` should be using RemoteCocoa. This
  // is equivalent to `GetHostForRemoteCocoaBrowser` return a non-null value,
  // except that this method does not cause an AppShimHost to be created.
  bool BrowserUsesRemoteCocoa(Browser* browser);

  // Return true if any non-bookmark app windows open.
  bool HasNonBookmarkAppWindowsOpen();

  // Called when the launch of the app was cancelled by the user. For example,
  // if the user clicks cancel during a protocol launch.
  void OnAppLaunchCancelled(content::BrowserContext* context,
                            const std::string& app_id);

  void UpdateAppBadge(
      Profile* profile,
      const webapps::AppId& app_id,
      const std::optional<badging::BadgeManager::BadgeValue>& badge);

  // Called to connect to a MacNotificationProvider instance in the app shim
  // process for the given app_id. This is only supported for multi-profile
  // app shims; but only legacy platform apps would use single-profile shims
  // anyway.
  // If there is no running app shim matching `app_id`, currently this method
  // instead returns a remote connected to a dummy notification provider. In
  // the future this will instead launch an app shim for `app_id` and connect
  // to that.
  mojo::Remote<mac_notifications::mojom::MacNotificationProvider>
  LaunchNotificationProvider(const webapps::AppId& app_id);

  // Triggers an OS-level notification permission request prompt to be shown by
  // the app shim corresponding to `app_id`. Returns the current state without
  // showing a prompt if permission has already been granted and/or denied to
  // the app shim.
  using RequestNotificationPermissionCallback =
      chrome::mojom::AppShim::RequestNotificationPermissionCallback;
  void ShowNotificationPermissionRequest(
      const webapps::AppId& app_id,
      RequestNotificationPermissionCallback callback);

  // Causes ShowNotificationPermissionRequest() to immediately call its callback
  // with the given `result`, rather than trying to request permission from the
  // app shim.
  void SetNotificationPermissionResponseForTesting(
      mac_notifications::mojom::RequestPermissionResult result) {
    notification_permission_result_for_testing_ = result;
  }

  // Opens the given app in the given profile in response to the user picking
  // said profile in the Profiles menu.
  void LaunchAppInProfile(const webapps::AppId& app_id,
                          const base::FilePath& profile_path);

  // AppShimHostBootstrap::Client:
  void OnShimProcessConnected(
      std::unique_ptr<AppShimHostBootstrap> bootstrap) override;

  // AppShimHost::Client:
  void OnShimLaunchRequested(
      AppShimHost* host,
      web_app::LaunchShimUpdateBehavior update_behavior,
      web_app::ShimLaunchMode launch_mode,
      base::OnceCallback<void(base::Process)> launched_callback,
      base::OnceClosure terminated_callback) override;
  void OnShimProcessDisconnected(AppShimHost* host) override;
  void OnShimFocus(AppShimHost* host) override;
  void OnShimReopen(AppShimHost* host) override;
  void OnShimOpenedFiles(AppShimHost* host,
                         const std::vector<base::FilePath>& files) override;
  void OnShimSelectedProfile(AppShimHost* host,
                             const base::FilePath& profile_path) override;
  void OnShimOpenedAppSettings(AppShimHost* host) override;
  void OnShimOpenedUrls(AppShimHost* host,
                        const std::vector<GURL>& urls) override;
  void OnShimOpenAppWithOverrideUrl(AppShimHost* host,
                                    const GURL& override_url) override;
  void OnShimWillTerminate(AppShimHost* host) override;
  void OnNotificationPermissionStatusChanged(
      AppShimHost* host,
      mac_notifications::mojom::PermissionStatus status) override;

  // AppLifetimeMonitor::Observer overrides:
  void OnAppStart(content::BrowserContext* context,
                  const std::string& app_id) override;
  void OnAppActivated(content::BrowserContext* context,
                      const std::string& app_id) override;
  void OnAppDeactivated(content::BrowserContext* context,
                        const std::string& app_id) override;
  void OnAppStop(content::BrowserContext* context,
                 const std::string& app_id) override;

  // ProfileManagerObserver overrides:
  void OnProfileAdded(Profile* profile) override;
  void OnProfileMarkedForPermanentDeletion(Profile* profile) override;
  void OnProfileManagerDestroying() override;

  // BrowserListObserver overrides:
  void OnBrowserAdded(Browser* browser) override;
  void OnBrowserRemoved(Browser* browser) override;
  void OnBrowserSetLastActive(Browser* browser) override;

  // ProfileObserver overrides:
  void OnProfileWillBeDestroyed(Profile* profile) override;

  // AvatarMenuObserver:
  void OnAvatarMenuChanged(AvatarMenu* menu) override;

  static base::apple::ScopedCFTypeRef<CFStringRef>
      BuildAppShimRequirementStringFromFrameworkRequirementString(CFStringRef);

  class AppShimObserver {
   public:
    virtual void OnShimProcessConnected(base::ProcessId pid) {}
    virtual void OnShimProcessConnectedAndAllLaunchesDone(
        base::ProcessId pid,
        chrome::mojom::AppShimLaunchResult result) {}
    virtual void OnShimReopen(base::ProcessId pid) {}
    virtual void OnShimOpenedURLs(base::ProcessId pid) {}
    // If this is overridden to return false, the regular notification action
    // code path is bypassed.
    virtual bool OnNotificationAction(
        mac_notifications::mojom::NotificationActionInfoPtr& info);
  };
  void SetAppShimObserverForTesting(AppShimObserver* observer) {
    app_shim_observer_ = observer;
  }

  // Simulates a launch as triggered by an app shim for the specific `app_id`.
  void LoadAndLaunchAppForTesting(const webapps::AppId& app_id);

 protected:
  typedef std::set<Browser*> BrowserSet;

  // Virtual for tests.
  virtual bool IsAcceptablyCodeSigned(audit_token_t audit_token) const;

  // Return the profile for |path|, only if it is already loaded.
  virtual Profile* ProfileForPath(const base::FilePath& path);

  // Return a profile to use for a background shim launch, virtual for tests.
  virtual Profile* ProfileForBackgroundShimLaunch(const webapps::AppId& app_id);

  // Load a profile and call |callback| when completed or failed.
  virtual void LoadProfileAsync(const base::FilePath& path,
                                base::OnceCallback<void(Profile*)> callback);

  // Wait for |profile|'s WebAppProvider registry to be started.
  virtual void WaitForAppRegistryReadyAsync(
      Profile* profile,
      base::OnceCallback<void()> callback);

  // Return true if the specified path is for a valid profile that is also
  // locked.
  virtual bool IsProfileLockedForPath(const base::FilePath& path);

  // Create an AppShimHost for the specified parameters (intercept-able for
  // tests).
  virtual std::unique_ptr<AppShimHost> CreateHost(
      AppShimHost::Client* client,
      const base::FilePath& profile_path,
      const webapps::AppId& app_id,
      bool use_remote_cocoa);

  // Open the specified URL in a new Chrome window. This is the fallback when
  // an app shim exists, but there is no profile or extension for it. If
  // |profile_path| is specified, then that profile is preferred, otherwise,
  // the last used profile is used.
  virtual void OpenAppURLInBrowserWindow(const base::FilePath& profile_path,
                                         const GURL& url);

  // Launch the user manager (in response to attempting to access a locked
  // profile).
  virtual void LaunchProfilePicker();

  // Terminate Chrome if Chrome attempted to quit, but was prevented from
  // quitting due to apps being open.
  virtual void MaybeTerminate();

  // Called when profile menu items may have changed. Rebuilds the profile
  // menu item list and sends updated lists to all apps.
  void UpdateAllProfileMenus();

  // Update |profile_menu_items_| from |avatar_menu_|. Virtual for tests.
  virtual void RebuildProfileMenuItemsFromAvatarMenu();

  // The list of all profiles that might appear in the menu.
  std::vector<chrome::mojom::ProfileMenuItemPtr> profile_menu_items_;

 private:
  friend class ScopedAppShimKeepAlive;

  // The state for an individual app, and for the profile-scoped app info.
  struct ProfileState;
  struct AppState;

  // Close all app shims associated with the specified profile.
  void CloseShimsForProfile(Profile* profile);

  // This is called by OnShimProcessConnected if the app shim was launched by
  // Chrome, and should connect to an already-existing AppShimHost.
  void OnShimProcessConnectedForRegisterOnly(
      std::unique_ptr<AppShimHostBootstrap> bootstrap);

  // The function LoadAndLaunchApp will:
  // - Find the appropriate profiles for which |app_id| should be launched.
  // - Load the profiles and ensure the app is enabled (using
  //   LoadProfileAndApp), if needed.
  // - Launch the app, if appropriate.
  // The "if appropriate" above is defined as:
  // - If `params.files` is non-empty, then will always launch the app
  //   - If `profile_path` is non-empty, then use that profile.
  //   - In the most recently used profile, otherwise
  // - If `params.files` is empty, then launch the app only if:
  //   - If `profile_path` is non-empty, then launch if the app is not running
  //     in that profile.
  //   - Otherwise, launch the app only if it is not running any profile.
  using LoadAndLaunchAppCallback =
      base::OnceCallback<void(ProfileState* profile_state,
                              chrome::mojom::AppShimLaunchResult result)>;
  struct LoadAndLaunchAppParams {
    LoadAndLaunchAppParams();
    ~LoadAndLaunchAppParams();
    LoadAndLaunchAppParams(const LoadAndLaunchAppParams&);
    LoadAndLaunchAppParams& operator=(const LoadAndLaunchAppParams&);

    // Return true if `files` or `urls` is non-empty. If so, then this launch
    // will open exactly one window.
    bool HasFilesOrURLs() const;

    webapps::AppId app_id;
    std::vector<base::FilePath> files;
    std::vector<GURL> urls;
    GURL override_url;
    chrome::mojom::AppShimLoginItemRestoreState login_item_restore_state =
        chrome::mojom::AppShimLoginItemRestoreState::kNone;
  };
  void LoadAndLaunchApp(const base::FilePath& profile_path,
                        const LoadAndLaunchAppParams& params,
                        LoadAndLaunchAppCallback launch_callback);
  bool LoadAndLaunchApp_TryExistingProfileStates(
      const base::FilePath& profile_path,
      const LoadAndLaunchAppParams& params,
      const std::map<base::FilePath, int>& profiles_with_handlers,
      LoadAndLaunchAppCallback* launch_callback);
  void LoadAndLaunchApp_OnProfilesAndAppReady(
      const std::vector<base::FilePath>& profile_paths_to_launch,
      bool first_profile_is_from_bootstrap,
      const LoadAndLaunchAppParams& params,
      LoadAndLaunchAppCallback launch_callback);
  void LoadAndLaunchApp_LaunchIfAppropriate(
      Profile* profile,
      ProfileState* profile_state,
      const LoadAndLaunchAppParams& params,
      base::OnceClosure launch_finished_callback);

  // The final step of both paths for OnShimProcessConnected. This will connect
  // |bootstrap| to |profile_state|'s AppShimHost, if possible. The value of
  // |profile_state| is non-null if and only if |result| is success.
  void OnShimProcessConnectedAndAllLaunchesDone(
      std::unique_ptr<AppShimHostBootstrap> bootstrap,
      ProfileState* profile_state,
      chrome::mojom::AppShimLaunchResult result);

  // Load the specified profile and extension, and run |callback| with
  // the result. The callback's arguments may be nullptr on failure.
  using LoadProfileAndAppCallback = base::OnceCallback<void(Profile*)>;
  void LoadProfileAndApp(const base::FilePath& profile_path,
                         const webapps::AppId& app_id,
                         LoadProfileAndAppCallback callback);
  void LoadProfileAndApp_OnProfileLoaded(const base::FilePath& profile_path,
                                         const webapps::AppId& app_id,
                                         LoadProfileAndAppCallback callback,
                                         Profile* profile);
  void LoadProfileAndApp_OnProfileAppRegistryReady(
      const base::FilePath& profile_path,
      const webapps::AppId& app_id,
      LoadProfileAndAppCallback callback);
  void LoadProfileAndApp_OnAppEnabled(const base::FilePath& profile_path,
                                      const webapps::AppId& app_id,
                                      LoadProfileAndAppCallback callback);

  // Update the profiles menu for the specified host.
  void UpdateAppProfileMenu(AppState* app_state);

  // Update the application dock menu for the specified host.
  void UpdateApplicationDockMenu(Profile* profile, ProfileState* profile_state);

  // Updates the badge for the specified host.
  void UpdateApplicationBadge(ProfileState* profile_state);

  // Retrieve the ProfileState for a given (Profile, AppId) pair. If one
  // does not exist, create one.
  ProfileState* GetOrCreateProfileState(Profile* profile,
                                        const webapps::AppId& app_id);

  // Launches a shim for `app_id` in background mode (i.e. without being shown
  // in the Dock and other UI surfaces). Can call `callback` with nullptr if the
  // `app_id` is invalid (for example not installed locally in any profile). If
  // the launch itself fails, this will still call `callback` with a valid
  // AppShimHost, but a mojo connection to the app shim will never be
  // established (and any calls that were made to the remote app shim will be
  // dropped).
  void LaunchShimInBackgroundMode(
      const webapps::AppId& app_id,
      base::OnceCallback<void(AppShimHost*)> callback);

  // Returns a mapping of profile paths to how many of the files and urls passed
  // in in `params` each profile can handle.
  static std::map<base::FilePath, int> GetProfilesWithMatchingHandlers(
      const LoadAndLaunchAppParams& params);

  // mac_notifications::mojom::MacNotificationProvider:
  void BindNotificationService(
      mojo::PendingReceiver<mac_notifications::mojom::MacNotificationService>
          service,
      mojo::PendingRemote<
          mac_notifications::mojom::MacNotificationActionHandler> handler)
      override;

  // mac_notifications::mojom::MacNotificationActionHandler:
  void OnNotificationAction(
      mac_notifications::mojom::NotificationActionInfoPtr info) override;

  std::unique_ptr<Delegate> delegate_;

  // Weak, reset during OnProfileManagerDestroying.
  raw_ptr<ProfileManager> profile_manager_ = nullptr;

  // Map from extension id to the state for that app.
  std::map<std::string, std::unique_ptr<AppState>> apps_;

  // The avatar menu instance used by all app shims.
  std::unique_ptr<AvatarMenu> avatar_menu_;

  // Requests for MacNotificationProviders that can't be connected to the
  // correct app shim process right away get added to this receiver set
  // instead. This is needed because higher level notifications code currently
  // always expects to get a connected MacNotificationProvider remote.
  mojo::ReceiverSet<mac_notifications::mojom::MacNotificationProvider>
      dummy_notification_provider_receivers_;

  // Notification actions from all app shims are routed through these receivers
  // and this class to make sure notification actions can be handled even if the
  // browser process has never tried to connect to the notification service
  // in an app shim.
  mojo::ReceiverSet<mac_notifications::mojom::MacNotificationActionHandler,
                    webapps::AppId>
      notification_action_handler_receivers_;

  // This contains `AppShimHostBootstrap` instances, keyed by the `ReceiverId`
  // for the corresponding `MacNotificationActionHandler` receiver in
  // `notification_action_handler_receivers_`, for app shims that were launched
  // by the OS to handle notification actions.
  std::map<mojo::ReceiverId, std::unique_ptr<AppShimHostBootstrap>>
      bootstraps_pending_notification_actions_;

  // Set in some tests to short-circuit ShowNotificationPermissionRequest.
  std::optional<mac_notifications::mojom::RequestPermissionResult>
      notification_permission_result_for_testing_;

  raw_ptr<AppShimObserver> app_shim_observer_ = nullptr;

  base::ScopedMultiSourceObservation<Profile, ProfileObserver>
      profile_observation_{this};

  base::WeakPtrFactory<AppShimManager> weak_factory_;
};

}  // namespace apps

#endif  // CHROME_BROWSER_APPS_APP_SHIM_APP_SHIM_MANAGER_MAC_H_