// 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_CAPTURE_MODE_CAPTURE_MODE_CAMERA_CONTROLLER_H_
#define ASH_CAPTURE_MODE_CAPTURE_MODE_CAMERA_CONTROLLER_H_

#include <string>
#include <vector>

#include "ash/ash_export.h"
#include "ash/capture_mode/capture_mode_behavior.h"
#include "ash/capture_mode/capture_mode_types.h"
#include "ash/system/tray/system_tray_observer.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/observer_list_types.h"
#include "base/system/system_monitor.h"
#include "base/timer/timer.h"
#include "media/base/video_facing.h"
#include "media/capture/video/video_capture_device_info.h"
#include "media/capture/video_capture_types.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/video_capture/public/mojom/video_source_provider.mojom.h"
#include "ui/views/widget/unique_widget_ptr.h"

namespace gfx {
class Rect;
}  // namespace gfx

namespace ash {

class CameraPreviewView;
class CaptureModeBehavior;
class CaptureModeDelegate;

// The ID used internally in capture mode to identify the camera.
class ASH_EXPORT CameraId {
 public:
  CameraId() = default;
  CameraId(std::string model_id, int number);
  CameraId(const CameraId&) = default;
  CameraId(CameraId&&) = default;
  CameraId& operator=(const CameraId&) = default;
  CameraId& operator=(CameraId&&) = default;
  ~CameraId() = default;

  bool is_valid() const { return !model_id_or_display_name_.empty(); }
  const std::string& model_id_or_display_name() const {
    return model_id_or_display_name_;
  }
  int number() const { return number_; }

  bool operator==(const CameraId& rhs) const {
    return model_id_or_display_name_ == rhs.model_id_or_display_name_ &&
           number_ == rhs.number_;
  }
  bool operator!=(const CameraId& rhs) const { return !(*this == rhs); }

  bool operator<(const CameraId& rhs) const;

  std::string ToString() const;

 private:
  // A unique hardware ID of the camera device in the form of
  // "[Vendor ID]:[Product ID]" (e.g. "0c45:6713"). Note that if multiple
  // cameras from the same vendor and of the same model are connected to the
  // device, they will all have the same `model_id`.
  // Note that in some cases, `media::VideoCaptureDeviceDescriptor::model_id`
  // may not be present. In this case, this will be filled by the camera's
  // display name.
  std::string model_id_or_display_name_;

  // A number that disambiguates cameras of the same type. For example if we
  // have two connected cameras of the same type, the first one will have
  // `number` set to 1, and the second's will be 2.
  int number_ = 0;
};

struct CameraInfo {
  CameraInfo(CameraId camera_id,
             std::string device_id,
             std::string display_name,
             const media::VideoCaptureFormats& supported_formats,
             media::VideoFacingMode camera_facing_mode);
  CameraInfo(CameraInfo&&);
  CameraInfo& operator=(CameraInfo&&);
  ~CameraInfo();

  // The ID used to identify the camera device internally to the capture mode
  // code, which should be more stable than the below `device_id` which may
  // change multiple times for the same camera.
  CameraId camera_id;

  // The ID of the camera device given to it by the system in its current
  // connection instance (e.g. "/dev/video2"). Note that the same camera device
  // can disconnect and reconnect with a different `device_id` (e.g. when the
  // cable is flaky). This ID is used to identify the camera to the video source
  // provider in the video capture service.
  std::string device_id;

  // The name of the camera device as shown to the end user (e.g. "Integrated
  // Webcam").
  std::string display_name;

  // A list of supported capture formats by this camera. This list is sorted
  // (See `media::VideoCaptureSystemImpl::DevicesInfoReady()`) by the frame size
  // area, then by frame width, then by the *largest* frame rate.
  media::VideoCaptureFormats supported_formats;

  // Whether the camera is facing the user (e.g. for internal front cameras), or
  // the environment (e.g. internal rear cameras), or unknown (e.g. usually for
  // external USB cameras).
  media::VideoFacingMode camera_facing_mode;
};

using CameraInfoList = std::vector<CameraInfo>;

// Controls detecting camera devices additions and removals and keeping a list
// of all currently connected cameras to the device. It also tracks all the
// capture mode selfie camera settings.
class ASH_EXPORT CaptureModeCameraController
    : public base::SystemMonitor::DevicesChangedObserver,
      public SystemTrayObserver {
 public:
  class Observer : public base::CheckedObserver {
   public:
    // Called to notify the observer that the list of `available_cameras_` has
    // changed, and provides that list as `cameras`.
    virtual void OnAvailableCamerasChanged(const CameraInfoList& cameras) = 0;

    // Called to notify the observer that a camera with `camera_id` was selected
    // and will be used to show a camera preview when possible.
    // Note that when `camera_id.is_valid()` is false, it means no camera is
    // currently selected.
    virtual void OnSelectedCameraChanged(const CameraId& camera_id) = 0;

   protected:
    ~Observer() override = default;
  };

  explicit CaptureModeCameraController(CaptureModeDelegate* delegate);
  CaptureModeCameraController(const CaptureModeCameraController&) = delete;
  CaptureModeCameraController& operator=(const CaptureModeCameraController&) =
      delete;
  ~CaptureModeCameraController() override;

  const CameraInfoList& available_cameras() const { return available_cameras_; }
  const CameraId& selected_camera() const { return selected_camera_; }
  views::Widget* camera_preview_widget() const {
    return camera_preview_widget_.get();
  }
  CameraPreviewView* camera_preview_view() const {
    return camera_preview_view_;
  }
  bool should_show_preview() const { return should_show_preview_; }
  CameraPreviewSnapPosition camera_preview_snap_position() const {
    return camera_preview_snap_position_;
  }
  bool is_drag_in_progress() const { return is_drag_in_progress_; }
  bool is_camera_preview_collapsed() const {
    return is_camera_preview_collapsed_;
  }
  bool did_user_ever_change_camera() const {
    return did_user_ever_change_camera_;
  }

  void AddObserver(Observer* observer);
  void RemoveObserver(Observer* observer);

  // Selects the first camera in the `available_cameras_` list (if any), and
  // only if no other camera is already selected.
  void MaybeSelectFirstCamera();

  // Reverts the automatic selection of the first available camera if one was
  // made by calling the `MaybeSelectFirstCamera()`.
  void MaybeRevertAutoCameraSelection();

  // Returns true if camera support is disabled by admins via
  // the `SystemFeaturesDisableList` policy, false otherwise.
  bool IsCameraDisabledByPolicy() const;

  // Returns the display name of `selected_camera_`. Returns an empty string if
  // the selected camera is not set.
  std::string GetDisplayNameOfSelectedCamera() const;

  // Sets the currently selected camera to the whose ID is the given
  // `camera_id`. If `camera_id` is invalid (see CameraId::is_valid()), this
  // clears the selected camera. `by_user` is true if the selection was made
  // explicitly by the user, false otherwise.
  void SetSelectedCamera(CameraId camera_id, bool by_user = false);

  // Sets `should_show_preview_` to the given `value`, and refreshes the state
  // of the camera preview.
  void SetShouldShowPreview(bool value);

  // Updates the parent of the `camera_preview_widget_` when necessary. E.g,
  // capture source type changes, selected recording window changes etc.
  void MaybeReparentPreviewWidget();

  // Sets `camera_preview_snap_position_` and updates the preview widget's
  // bounds accordingly. If `animate` is set to true, the camera preview will
  // animate to its new snap position.
  void SetCameraPreviewSnapPosition(CameraPreviewSnapPosition value,
                                    bool animate = false);

  // Updates the bounds and visibility of `camera_preview_widget_` according to
  // the current state of the capture surface within which the camera preview
  // is confined and snapped to one of its corners. If `animate` is set to true,
  // the widget will animate to the new target bounds.
  void MaybeUpdatePreviewWidget(bool animate = false);

  // Handles drag events forwarded from `camera_preview_view_`.
  void StartDraggingPreview(const gfx::PointF& screen_location);
  void ContinueDraggingPreview(const gfx::PointF& screen_location);
  void EndDraggingPreview(const gfx::PointF& screen_location, bool is_touch);

  // Updates the bounds of the preview widget and the value of
  // `is_camera_preview_collapsed_` when the resize button is pressed.
  void ToggleCameraPreviewSize();

  // Called when a capture session gets started so we can refresh the cameras
  // list, since the cros-camera service might have not been running when we
  // tried to refresh the cameras at the beginning. (See
  // http://b/230917107#comment12 for more details).
  void OnCaptureSessionStarted();

  void OnRecordingStarted(const CaptureModeBehavior* active_behavior);
  void OnRecordingEnded();

  // Called when the `CameraVideoFrameHandler` of the current
  // `camera_preview_widget_` encounters a fatal error. This is considered a
  // camera disconnection, and sometimes doesn't get reported via
  // `OnDevicesChanged()` below, or may get delayed a lot. We manually remove
  // the current camera from `available_cameras_`, delete its preview, and
  // request a new list of cameras from the video capture service.
  // https://crbug/1316230.
  void OnFrameHandlerFatalError();

  // Called when the device is shutting down. After this call, we don't do any
  // operations that interacts with the video capture service.
  void OnShuttingDown();

  // As `camera_preview_view_` is a
  // CaptureModeSessionFocusCycler::HighlightableView. This will show the focus
  // ring and trigger setting a11y focus on the camera preview. Note, this is
  // only for focusing the preview while recording is in progress.
  void PseudoFocusCameraPreview();

  void OnActiveUserSessionChanged();

  // base::SystemMonitor::DevicesChangedObserver:
  void OnDevicesChanged(base::SystemMonitor::DeviceType device_type) override;

  // SystemTrayObserver:
  void OnSystemTrayBubbleShown() override;
  void OnFocusLeavingSystemTray(bool reverse) override {}
  void OnStatusAreaAnchoredBubbleVisibilityChanged(TrayBubbleView* tray_bubble,
                                                   bool visible) override;

  void SetOnCameraListReceivedForTesting(base::OnceClosure callback) {
    on_camera_list_received_for_test_ = std::move(callback);
  }

  base::OneShotTimer* camera_reconnect_timer_for_test() {
    return &camera_reconnect_timer_;
  }

 private:
  friend class CaptureModeTestApi;

  // Called to connect to the video capture services's video source provider for
  // the first time, or when the connection to it is lost. It also queries the
  // list of currently available cameras by calling the below
  // GetCameraDevices().
  void ReconnectToVideoSourceProvider();

  // Retrieves the list of currently available cameras from the video source
  // provider.
  void GetCameraDevices();

  // Called back asynchronously by the video source provider to give us the list
  // of currently available camera `devices`. The ID used to make the request to
  // which this reply belongs is `request_id`. We will ignore any replies for
  // any older requests than the `most_recent_request_id_`.
  using RequestId = size_t;
  void OnCameraDevicesReceived(
      RequestId request_id,
      video_capture::mojom::VideoSourceProvider::GetSourceInfosResult,
      const std::vector<media::VideoCaptureDeviceInfo>& devices);

  // Shows or hides a preview of the currently selected camera depending on
  // whether it's currently allowed and whether one is currently selected.
  void RefreshCameraPreview();

  // Triggered when the `camera_reconnect_timer_` fires, indicating that a
  // previously `selected_camera_` remained disconnected for longer than the
  // allowed grace period, and therefore it will be cleared.
  void OnSelectedCameraDisconnected();

  // Returns the bounds of the preview widget which doesn't intersect with
  // system tray, which should be confined within the given `confine_bounds`,
  // and have the given `preview_size`. Always tries the current
  // `camera_preview_snap_position_` first. Once a snap position with which the
  // preview has no collisions is found, it will be set in
  // `camera_preview_snap_position_`. If the camera preview at all possible snap
  // positions intersects with system tray, returns the bounds for the current
  // `camera_preview_snap_position_`.
  gfx::Rect CalculatePreviewWidgetTargetBounds(const gfx::Rect& confine_bounds,
                                               const gfx::Size& preview_size);

  // Called by `CalculatePreviewWidgetTargetBounds` above. Returns the bounds of
  // the preview widget that matches the coordinate system of the given
  // `confine_bounds` with the given `preview_size` at the given
  // `snap_position`.
  gfx::Rect GetPreviewWidgetBoundsForSnapPosition(
      const gfx::Rect& confine_bounds,
      const gfx::Size& preview_size,
      CameraPreviewSnapPosition snap_position) const;

  // Returns the new snap position of the camera preview on drag ended.
  CameraPreviewSnapPosition CalculateSnapPositionOnDragEnded() const;

  // Returns the current bounds of camemra preview widget that match the
  // coordinate system of the confine bounds.
  gfx::Rect GetCurrentBoundsMatchingConfineBoundsCoordinates() const;

  // Does post works for camera preview after RefreshCameraPreview(). It
  // triggers a11y alert based on `was_preview_visible_before` and the current
  // visibility of `camera_preview_widget_`. `was_preview_visible_before` is the
  // visibility of the camera preview when RefreshCameraPreview() was called.
  // It also triggers floating windows bounds update to avoid overlap between
  // camera preview and floating windows, such as PIP windows and some a11y
  // panels.
  void RunPostRefreshCameraPreview(bool was_preview_visible_before);

  // Sets the given `target_bounds` on the camera preview widget, potentially
  // animating to it if `animate` is true. Returns true if the bounds actually
  // changed from the current.
  bool SetCameraPreviewBounds(const gfx::Rect& target_bounds, bool animate);

  // Owned by CaptureModeController and guaranteed to be not null and to outlive
  // `this`.
  const raw_ptr<CaptureModeDelegate> delegate_;

  // The remote end to the video source provider that exists in the video
  // capture service.
  mojo::Remote<video_capture::mojom::VideoSourceProvider>
      video_source_provider_remote_;

  CameraInfoList available_cameras_;

  // The currently selected camera. If its `is_valid()` is false, then no camera
  // is currently selected.
  CameraId selected_camera_;

  base::ObserverList<Observer> observers_;

  // If bound, will be invoked at the end of the scope of
  // `OnCameraDevicesReceived()` regardless of whether there was a change in the
  // available cameras or not, which is different from the behavior of
  // `Observer::OnAvailableCamerasChanged()` which is called only when there is
  // a change.
  base::OnceClosure on_camera_list_received_for_test_;

  // The camera preview widget and its contents view.
  views::UniqueWidgetPtr camera_preview_widget_;
  raw_ptr<CameraPreviewView> camera_preview_view_ = nullptr;

  // A timer used to give a `selected_camera_` that got disconnected a grace
  // period, so if it reconnects again within this period, its ID is kept around
  // in `selected_camera_`, otherwise the ID is cleared, effectively resetting
  // back the camera setting to "Off".
  base::OneShotTimer camera_reconnect_timer_;

  // Set to true when a preview of the currently selected camera (if any) should
  // be shown. This happens when CaptureModeSession is started and switched to
  // a video recording mode before recording starts. It is reset back to false
  // when:
  // - Video recording ends.
  // - The selected camera is disconnected for longer than a grace period during
  //   recording.
  // - The capture mode session ends without starting any recording.
  // - The capture mode session is switched to an image capture mode.
  bool should_show_preview_ = false;

  // The ID used for the most recent request made to the video source provider
  // to get the list of cameras in GetCameraDevices(). More recent requests will
  // have a larger value IDs than older requests.
  RequestId most_recent_request_id_ = 0;

  CameraPreviewSnapPosition camera_preview_snap_position_ =
      CameraPreviewSnapPosition::kBottomRight;

  // The location of the previous drag event in screen coordinate.
  gfx::PointF previous_location_in_screen_;

  // True when the dragging for `camera_preview_view_` is in progress.
  bool is_drag_in_progress_ = false;

  // True if the camera preview is collapsed. Its value will be updated when
  // the resize button is clicked. The size of the preview widget and the icon
  // of the resize button will be updated based on it.
  bool is_camera_preview_collapsed_ = false;

  // True if it's the first time to update the camera preview's bounds after
  // it's created.
  bool is_first_bounds_update_ = false;

  // True when the device is shutting down, and we should no longer make any
  // requests to the video capture service.
  bool is_shutting_down_ = false;

  // Valid only during recording to track the number of camera disconnections
  // while recording is in progress.
  std::optional<int> in_recording_camera_disconnections_;

  // Will be set to true the first time the number of connected cameras is
  // reported.
  bool did_report_number_of_cameras_before_ = false;

  // Will be set to true the first user logs in. And we should only request the
  // camera devices after the first user logs in.
  bool did_first_user_login_ = false;

  // True if the first available camera was auto-selected by calling
  // `MaybeSelectFirstCamera()`, false otherwise or if
  // `MaybeRevertAutoCameraSelection()` was called to revert back this automatic
  // selection.
  bool did_make_camera_auto_selection_ = false;

  // True if the user ever made an explicit camera selection (i.e. from the
  // capture mode settings menu).
  bool did_user_ever_change_camera_ = false;

  base::WeakPtrFactory<CaptureModeCameraController> weak_ptr_factory_{this};
};

}  // namespace ash

#endif  // ASH_CAPTURE_MODE_CAPTURE_MODE_CAMERA_CONTROLLER_H_