// 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.

#ifndef ASH_SYSTEM_CAMERA_CAMERA_EFFECTS_CONTROLLER_H_
#define ASH_SYSTEM_CAMERA_CAMERA_EFFECTS_CONTROLLER_H_

#include <string>
#include <utility>

#include "ash/ash_export.h"
#include "ash/public/cpp/session/session_controller.h"
#include "ash/public/cpp/session/session_observer.h"
#include "ash/public/cpp/wallpaper/sea_pen_image.h"
#include "ash/system/camera/autozoom_observer.h"
#include "ash/system/video_conference/effects/video_conference_tray_effects_delegate.h"
#include "ash/system/video_conference/video_conference_tray_controller.h"
#include "base/files/file_path.h"
#include "base/memory/weak_ptr.h"
#include "base/scoped_observation.h"
#include "media/capture/video/chromeos/camera_hal_dispatcher_impl.h"
#include "media/capture/video/chromeos/mojom/effects_pipeline.mojom.h"

class PrefRegistrySimple;
class PrefService;
class PrefChangeRegistrar;

namespace gfx {
struct VectorIcon;
}  // namespace gfx

namespace ash {

enum class VcEffectId;

// CameraEffectsController is the interface for any object in ash to
// enable/change camera effects.
class ASH_EXPORT CameraEffectsController
    : public AutozoomObserver,
      public media::CameraEffectObserver,
      public SessionObserver,
      public VcEffectsDelegate,
      public VideoConferenceTrayEffectsManager::Observer {
 public:
  // Enum that represents the value persisted  to `prefs::kBackgroundBlur`,
  // which is the "ultimate source of truth" for the background blur setting.
  // WARNING: This enum and `prefs::kBackgroundBlur` should always be in sync.
  // Any changes made to this enum or `prefs::kBackgroundBlur` should also be
  // reflected in the other place.
  enum BackgroundBlurPrefValue {
    kOff = -1,
    kLowest = 0,
    kLight = 1,
    kMedium = 2,
    kHeavy = 3,
    kMaximum = 4,
    kImage = 5
  };

  // This enum contains all the state of the background blur effect. This enum
  // is used for metrics collection (we cannot use `BackgroundBlurPrefValue`
  // since `base::UmaHistogramEnumeration` cannot take a negative value for
  // an enum). Note to keep in sync with enum in
  // tools/metrics/histograms/metadata/ash/enums.xml.
  enum class BackgroundBlurState {
    kOff = 0,
    kLowest = 1,
    kLight = 2,
    kMedium = 3,
    kHeavy = 4,
    kMaximum = 5,
    kImage = 6,
    kMaxValue = kImage
  };

  // Information of a single background image file used in the ui.
  struct BackgroundImageInfo {
    base::Time creation_time;
    base::Time last_accessed;
    base::FilePath basename;
    gfx::ImageSkia image;
    std::string metadata;

    BackgroundImageInfo(const BackgroundImageInfo& info);
    BackgroundImageInfo(const base::Time& creation_time,
                        const base::Time& last_accessed,
                        const base::FilePath& basename,
                        const gfx::ImageSkia& image,
                        const std::string& metadata);
  };

  // Called inside ash/ash_prefs.cc to register related prefs.
  static void RegisterProfilePrefs(PrefRegistrySimple* registry);

  static base::FilePath SeaPenIdToRelativePath(uint32_t id);

  CameraEffectsController();

  CameraEffectsController(const CameraEffectsController&) = delete;
  CameraEffectsController& operator=(const CameraEffectsController&) = delete;

  ~CameraEffectsController() override;

  // Returns 'true' if UI controls for `effect` are available to the user,
  // 'false' otherwise.
  bool IsEffectControlAvailable(
      cros::mojom::CameraEffect effect = cros::mojom::CameraEffect::kNone);

  // Returns currently applied camera effects.
  // Should only be called after user logs in.
  cros::mojom::EffectsConfigPtr GetCameraEffects();

  // Sets an image as the camera background.
  // The `relative_path` is relative to `camera_background_img_dir_` and the
  // file has to exist for the effect to work.
  void SetBackgroundImage(const base::FilePath& relative_path,
                          base::OnceCallback<void(bool)> callback);

  // Saves the `jpeg_bytes` as an image file with `metadata` and apply that as
  // camera background.
  void SetBackgroundImageFromContent(const SeaPenImage& sea_pen_image,
                                     const std::string& metadata,
                                     base::OnceCallback<void(bool)> callback);

  // Removes `basename` from the camera background directory; remove background
  // effect if the same file is used as camera background right now.
  void RemoveBackgroundImage(const base::FilePath& basename,
                             base::OnceCallback<void(bool)> callback);

  // Gets `number_of_images` recently used camera background images, and calls
  // the `callback` on the returned list.
  void GetRecentlyUsedBackgroundImages(
      const int number_of_images,
      base::OnceCallback<void(const std::vector<BackgroundImageInfo>&)>
          callback);

  // Gets the full list of used background image paths and calls `callback` on
  // that.
  void GetBackgroundImageFileNames(
      base::OnceCallback<void(const std::vector<base::FilePath>&)> callback);

  // Gets the BackgroundImageInfo for the `basename` and calls `callback` on
  // that.
  void GetBackgroundImageInfo(
      const base::FilePath& basename,
      base::OnceCallback<void(const std::optional<BackgroundImageInfo>&)>
          callback);

  bool IsEligibleForBackgroundReplace();

  bool IsVcBackgroundAllowedByEnterprise();

  // SessionObserver:
  void OnActiveUserSessionChanged(const AccountId& account_id) override;
  void OnActiveUserPrefServiceChanged(PrefService* pref_service) override;

  // VcEffectsDelegate:
  std::optional<int> GetEffectState(VcEffectId effect_id) override;
  void OnEffectControlActivated(VcEffectId effect_id,
                                std::optional<int> state) override;
  void RecordMetricsForSetValueEffectOnClick(VcEffectId effect_id,
                                             int state_value) const override;
  void RecordMetricsForSetValueEffectOnStartup(VcEffectId effect_id,
                                               int state_value) const override;

  // media::CameraEffectObserver:
  void OnCameraEffectChanged(
      const cros::mojom::EffectsConfigPtr& new_effects) final;

  // VideoConferenceTrayEffectsManager::Observer
  // When video conference bubble is opened, update background blur effect in
  // two cases:
  // - Add Image state when the background replace eligible state changes from
  // false -> true. This happens at most one time for enterprise users.
  // - Disable/enable Image state button when background replace is already
  // eligibled and enterprise policy setting changes. VC Background policy is
  // dynamic-refreshed and UI should update if any changes.
  void OnVideoConferenceBubbleOpened() override;

  void bypass_set_camera_effects_for_testing(bool in_testing_mode) {
    in_testing_mode_ = in_testing_mode;
  }

  void set_camera_background_img_dir_for_testing(
      const base::FilePath& camera_background_img_dir) {
    camera_background_img_dir_ = camera_background_img_dir;
  }

  void set_camera_background_run_dir_for_testing(
      const base::FilePath& camera_background_run_dir) {
    camera_background_run_dir_ = camera_background_run_dir;
  }

  // Background images are resized to have this width when they are used as icon
  // in the sysui or webui.
  static constexpr int kImageAsIconWidth = 512;

  bool is_eligible_for_background_replace() const {
    return is_eligible_for_background_replace_;
  }

 private:
  // AutozoomObserver:
  void OnAutozoomControlEnabledChanged(bool enabled) override;

  // Returns the segmentation model that should be used in the effects pipeline
  // based on the value of the feature flag.
  cros::mojom::SegmentationModel GetSegmentationModelType();

  // SetCameraEffects camera effects with `config`.
  // `copy_background_image_complete_callback` is only called after background
  // image is copied to `camera_background_run_dir_` which is only necessary
  // when a new image is applied.
  void SetCameraEffects(
      cros::mojom::EffectsConfigPtr config,
      bool is_initialization,
      base::OnceCallback<void(bool)> copy_background_image_complete_callback);

  // Called only after copying background images to
  // `camera_background_run_dir_`. If `copy_succeeded`, then `new_config` will
  // be applied. If `copy_succeeded` is false, but `is_initialization`, then we
  // will still apply other effects except background replace.
  // `copy_background_image_complete_callback` is called on `copy_succeeded`.
  void OnCopyBackgroundImageFileComplete(
      cros::mojom::EffectsConfigPtr new_config,
      bool is_initialization,
      base::OnceCallback<void(bool)> copy_background_image_complete_callback,
      bool copy_succeeded);

  // Called when some image content is saved inside
  // `camera_background_run_dir_`. Called with actual file basename if the
  // saving succeeded, otherwise called on empty path.
  void OnSaveBackgroundImageFileComplete(
      base::OnceCallback<void(bool)> callback,
      const base::FilePath& basename);

  // Constructs EffectsConfigPtr from prefs.
  cros::mojom::EffectsConfigPtr GetEffectsConfigFromPref();

  // Update prefs with the value in `config`.
  void SetEffectsConfigToPref(cros::mojom::EffectsConfigPtr config);

  // Performs any initializations needed for effects whose controls are
  // exposed via the UI.
  void InitializeEffectControls();

  void AddBackgroundBlurEffect();

  // Adds a `std::unique_ptr<VcEffectState>` to `effect`, where `effect` is
  // assumed to be that of camera background blur.
  void AddBackgroundBlurStateToEffect(VcHostedEffect* effect,
                                      const gfx::VectorIcon& icon,
                                      int state_value,
                                      int string_id,
                                      int view_id,
                                      bool is_disabled_by_enterprise);

  // A helper for easier binding.
  void SetCameraEffectsInCameraHalDispatcherImpl(
      cros::mojom::EffectsConfigPtr config);

  // Used to bypass the CameraHalDispatcherImpl::SetCameraEffects for
  // testing purpose.
  bool in_testing_mode_ = false;

  bool is_eligible_for_background_replace_ = false;

  bool is_background_replace_disabled_by_enterprise_ = false;

  // Directory that stores the camera background images.
  base::FilePath camera_background_img_dir_;

  // Directory that stores the background images for the camera module to use.
  base::FilePath camera_background_run_dir_;

  // Used for pref registration.
  std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;

  // This task runner is used to ensure `current_effects_` is always accessed
  // from the same thread.
  const scoped_refptr<base::SequencedTaskRunner> main_task_runner_;

  // This task runner is used to run io work.
  const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;

  base::ScopedObservation<media::CameraHalDispatcherImpl,
                          media::CameraEffectObserver>
      scoped_camera_effect_observation_{this};

  // Records current effects that is applied to camera hal server.
  cros::mojom::EffectsConfigPtr current_effects_;

  base::ScopedObservation<SessionController, SessionObserver>
      session_observation_{this};

  base::WeakPtrFactory<CameraEffectsController> weak_factory_{this};
};

}  // namespace ash

#endif  // ASH_SYSTEM_CAMERA_CAMERA_EFFECTS_CONTROLLER_H_