/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_
#define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_

#include <set>

#include "request_processor.h"
#include "result_processor.h"
#include "vendor_tag_defs.h"

namespace android {
namespace google_camera_hal {

// RgbirdResultRequestProcessor implements a ResultProcessor handling realtime
// capture results for a logical camera consisting of one RGB and two IR camera
// sensors.
class RgbirdResultRequestProcessor : public ResultProcessor,
                                     public RequestProcessor {
 public:
  struct RgbirdResultRequestProcessorCreateData {
    // camera id of the color sensor
    uint32_t rgb_camera_id = 0;
    // camera id of the NIR sensor used as source
    uint32_t ir1_camera_id = 0;
    // camera id of the NIR sensor used as target
    uint32_t ir2_camera_id = 0;
    // stream id of the internal raw stream for hdr+
    int32_t rgb_raw_stream_id = -1;
    // whether hdr+ is supported
    bool is_hdrplus_supported = false;
    // stream id of the internal yuv stream in case depth is configured
    int32_t rgb_internal_yuv_stream_id = -1;
  };

  static std::unique_ptr<RgbirdResultRequestProcessor> Create(
      const RgbirdResultRequestProcessorCreateData& create_data);

  virtual ~RgbirdResultRequestProcessor() = default;

  // Override functions of ResultProcessor start.
  void SetResultCallback(
      ProcessCaptureResultFunc process_capture_result, NotifyFunc notify,
      ProcessBatchCaptureResultFunc process_batch_capture_result) override;

  status_t AddPendingRequests(
      const std::vector<ProcessBlockRequest>& process_block_requests,
      const CaptureRequest& remaining_session_request) override;

  void ProcessResult(ProcessBlockResult block_result) override;

  void Notify(const ProcessBlockNotifyMessage& block_message) override;

  status_t FlushPendingRequests() override;
  // Override functions of ResultProcessor end.

  // Override functions of RequestProcessor start.
  status_t ConfigureStreams(
      InternalStreamManager* internal_stream_manager,
      const StreamConfiguration& stream_config,
      StreamConfiguration* process_block_stream_config) override;

  status_t SetProcessBlock(std::unique_ptr<ProcessBlock> process_block) override;

  status_t ProcessRequest(const CaptureRequest& request) override;

  status_t Flush() override;
  // Override functions of RequestProcessor end.

 protected:
  RgbirdResultRequestProcessor(
      const RgbirdResultRequestProcessorCreateData& create_data);

 private:
  static constexpr int32_t kInvalidStreamId = -1;
  static constexpr uint32_t kAutocalFrameNumber = 5;
  static constexpr uint32_t kNumOfAutoCalInputBuffers = /*YUV+IR+IR*/ 3;
  const uint32_t kRgbCameraId;
  const uint32_t kIr1CameraId;
  const uint32_t kIr2CameraId;
  const int32_t kSyncWaitTime = 5000;  // milliseconds

  void ProcessResultForHdrplus(CaptureResult* result, bool* rgb_raw_output);
  // Return the RGB internal YUV stream buffer if there is any and depth is
  // configured
  void TryReturnInternalBufferForDepth(CaptureResult* result,
                                       bool* has_internal);

  // Save face detect mode for HDR+
  void SaveFdForHdrplus(const CaptureRequest& request);
  // Handle face detect metadata from result for HDR+
  status_t HandleFdResultForHdrplus(uint32_t frameNumber,
                                    HalCameraMetadata* metadata);
  // Save lens shading map mode for HDR+
  void SaveLsForHdrplus(const CaptureRequest& request);
  // Handle Lens shading metadata from result for HDR+
  status_t HandleLsResultForHdrplus(uint32_t frameNumber,
                                    HalCameraMetadata* metadata);
  // TODO(b/127322570): update the following function after FLL sync verified
  // Remove internal streams for depth lock
  status_t ReturnInternalStreams(CaptureResult* result);

  // Check fence status if need
  status_t CheckFenceStatus(CaptureRequest* request);

  // Check all metadata exist for Autocal
  // Protected by depth_requests_mutex_
  bool IsAutocalMetadataReadyLocked(const HalCameraMetadata& metadata);

  // Prepare Depth Process Block request and try to submit that
  status_t TrySubmitDepthProcessBlockRequest(
      const ProcessBlockResult& block_result);

  // Whether the internal yuv stream buffer needs to be passed to the depth
  // process block.
  bool IsAutocalRequest(uint32_t frame_number) const;

  // Verify if all information is ready for a depth request for frame_number and
  // submit the request to the process block if so.
  status_t VerifyAndSubmitDepthRequest(uint32_t frame_number);

  std::mutex callback_lock_;

  // The following callbacks must be protected by callback_lock_.
  ProcessCaptureResultFunc process_capture_result_;
  NotifyFunc notify_;

  std::mutex depth_process_block_lock_;
  // Protected by depth_process_block_lock_.
  std::unique_ptr<ProcessBlock> depth_process_block_;

  // rgb_raw_stream_id_ is the stream ID of internal raw from RGB camera for HDR+
  int32_t rgb_raw_stream_id_ = -1;
  bool is_hdrplus_supported_ = false;

  // Current face detect mode set by framework.
  uint8_t current_face_detect_mode_ = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;

  std::mutex face_detect_lock_;
  // Map from frame number to face detect mode requested for that frame by
  // framework. And requested_face_detect_modes_ is protected by
  // face_detect_lock_
  std::unordered_map<uint32_t, uint8_t> requested_face_detect_modes_;

  // Current lens shading map mode set by framework.
  uint8_t current_lens_shading_map_mode_ =
      ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;

  std::mutex lens_shading_lock_;
  // Map from frame number to lens shading map mode requested for that frame
  // by framework. And requested_lens_shading_map_modes_ is protected by
  // lens_shading_lock_
  std::unordered_map<uint32_t, uint8_t> requested_lens_shading_map_modes_;

  // Internal stream manager
  InternalStreamManager* internal_stream_manager_ = nullptr;

  // TODO(b/128633958): remove this after FLL syncing is verified
  bool force_internal_stream_ = false;

  // Set of framework stream id
  std::set<int32_t> framework_stream_id_set_;

  std::mutex depth_requests_mutex_;

  // Map from framework number to capture request for depth process block. If a
  // request does not contain any depth buffer, it is not recorded in the map.
  // Protected by depth_requests_mutex_
  std::unordered_map<uint32_t, std::unique_ptr<CaptureRequest>> depth_requests_;

  // Depth stream id if it is configured for the current session
  int32_t depth_stream_id_ = -1;

  // If a depth stream is configured, always configure an extra internal YUV
  // stream to cover the case when there is no request for any stream from the
  // RGB sensor.
  int32_t rgb_internal_yuv_stream_id_ = -1;

  // Whether RGB-IR auto-calibration is enabled. This affects how the internal
  // YUV stream results are handled.
  bool rgb_ir_auto_cal_enabled_ = false;
};

}  // namespace google_camera_hal
}  // namespace android

#endif  // HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_