/*
 * Copyright 2022 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 ANDROID_HWC_DISPLAY_H
#define ANDROID_HWC_DISPLAY_H

#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
#include <aidl/android/hardware/graphics/composer3/ColorMode.h>
#include <aidl/android/hardware/graphics/composer3/ContentType.h>
#include <aidl/android/hardware/graphics/composer3/DisplayAttribute.h>
#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
#include <aidl/android/hardware/graphics/composer3/DisplayConnectionType.h>
#include <aidl/android/hardware/graphics/composer3/DisplayContentSample.h>
#include <aidl/android/hardware/graphics/composer3/DisplayIdentification.h>
#include <aidl/android/hardware/graphics/composer3/HdrCapabilities.h>
#include <aidl/android/hardware/graphics/composer3/PerFrameMetadataKey.h>
#include <aidl/android/hardware/graphics/composer3/PowerMode.h>
#include <aidl/android/hardware/graphics/composer3/ReadbackBufferAttributes.h>
#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
#include <aidl/android/hardware/graphics/composer3/VsyncPeriodChangeConstraints.h>
#include <aidl/android/hardware/graphics/composer3/VsyncPeriodChangeTimeline.h>
#include <android-base/unique_fd.h>

#include <array>
#include <mutex>
#include <optional>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "Common.h"
#include "DisplayChanges.h"
#include "DisplayConfig.h"
#include "DisplayFinder.h"
#include "FencedBuffer.h"
#include "FrameComposer.h"
#include "Layer.h"
#include "Time.h"
#include "VsyncThread.h"

namespace aidl::android::hardware::graphics::composer3::impl {

class FrameComposer;

class Display {
 public:
  Display(FrameComposer* composer, int64_t id);
  ~Display();

  Display(const Display& display) = delete;
  Display& operator=(const Display& display) = delete;

  Display(Display&& display) = delete;
  Display& operator=(Display&& display) = delete;

  HWC3::Error init(
      const std::vector<DisplayConfig>& configs, int32_t activeConfigId,
      const std::optional<std::vector<uint8_t>>& edid = std::nullopt);

  HWC3::Error updateParameters(
      uint32_t width, uint32_t height, uint32_t dpiX, uint32_t dpiY,
      uint32_t refreshRateHz,
      const std::optional<std::vector<uint8_t>>& edid = std::nullopt);

  // HWComposer3 interface.
  HWC3::Error createLayer(int64_t* outLayerId);
  HWC3::Error destroyLayer(int64_t layerId);
  HWC3::Error getActiveConfig(int32_t* outConfigId);
  HWC3::Error getDisplayAttribute(int32_t configId, DisplayAttribute attribute,
                                  int32_t* outValue);
  HWC3::Error getColorModes(std::vector<ColorMode>* outColorModes);
  HWC3::Error getDisplayCapabilities(std::vector<DisplayCapability>* caps);
  HWC3::Error getDisplayConfigs(std::vector<int32_t>* configs);
  HWC3::Error getDisplayConnectionType(DisplayConnectionType* outType);
  HWC3::Error getDisplayIdentificationData(
      DisplayIdentification* outIdentification);
  HWC3::Error getDisplayName(std::string* outName);
  HWC3::Error getDisplayVsyncPeriod(int32_t* outVsyncPeriod);
  HWC3::Error getDisplayedContentSample(int64_t maxFrames, int64_t timestamp,
                                        DisplayContentSample* samples);
  HWC3::Error getDisplayedContentSamplingAttributes(
      DisplayContentSamplingAttributes* outAttributes);
  HWC3::Error getDisplayPhysicalOrientation(common::Transform* outOrientation);
  HWC3::Error getHdrCapabilities(HdrCapabilities* outCapabilities);
  HWC3::Error getPerFrameMetadataKeys(
      std::vector<PerFrameMetadataKey>* outKeys);
  HWC3::Error getReadbackBufferAttributes(ReadbackBufferAttributes* attrs);
  HWC3::Error getReadbackBufferFence(ndk::ScopedFileDescriptor* acquireFence);
  HWC3::Error getRenderIntents(ColorMode mode,
                               std::vector<RenderIntent>* intents);
  HWC3::Error getSupportedContentTypes(std::vector<ContentType>* types);
  HWC3::Error getDecorationSupport(
      std::optional<common::DisplayDecorationSupport>* support);
  HWC3::Error registerCallback(
      const std::shared_ptr<IComposerCallback>& callback);
  HWC3::Error setActiveConfig(int32_t configId);
  HWC3::Error setActiveConfigWithConstraints(
      int32_t config, const VsyncPeriodChangeConstraints& constraints,
      VsyncPeriodChangeTimeline* outTimeline);
  HWC3::Error setBootConfig(int32_t configId);
  HWC3::Error clearBootConfig();
  HWC3::Error getPreferredBootConfig(int32_t* outConfigId);
  HWC3::Error setAutoLowLatencyMode(bool on);
  HWC3::Error setColorMode(ColorMode mode, RenderIntent intent);
  HWC3::Error setContentType(ContentType contentType);
  HWC3::Error setDisplayedContentSamplingEnabled(
      bool enable, FormatColorComponent componentMask, int64_t maxFrames);
  HWC3::Error setPowerMode(PowerMode mode);
  HWC3::Error setReadbackBuffer(const buffer_handle_t buffer,
                                const ndk::ScopedFileDescriptor& releaseFence);
  HWC3::Error setVsyncEnabled(bool enabled);
  HWC3::Error setIdleTimerEnabled(int32_t timeoutMs);
  HWC3::Error setColorTransform(const std::vector<float>& transform);
  HWC3::Error setBrightness(float brightness);
  HWC3::Error setClientTarget(buffer_handle_t buffer,
                              const ndk::ScopedFileDescriptor& fence,
                              common::Dataspace dataspace,
                              const std::vector<common::Rect>& damage);
  HWC3::Error setOutputBuffer(buffer_handle_t buffer,
                              const ndk::ScopedFileDescriptor& fence);
  HWC3::Error setExpectedPresentTime(
      const std::optional<ClockMonotonicTimestamp>& expectedPresentTime);
  HWC3::Error validate(DisplayChanges* outChanges);
  HWC3::Error acceptChanges();
  HWC3::Error present(
      ::android::base::unique_fd* outDisplayFence,
      std::unordered_map<int64_t, ::android::base::unique_fd>* outLayerFences);

  // Non HWCComposer3 interface.
  int64_t getId() const { return mId; }

  Layer* getLayer(int64_t layerHandle);

  HWC3::Error setEdid(std::vector<uint8_t> edid);

  bool hasColorTransform() const { return mColorTransform.has_value(); }
  std::array<float, 16> getColorTransform() const { return *mColorTransform; }

  FencedBuffer& getClientTarget() { return mClientTarget; }
  buffer_handle_t waitAndGetClientTargetBuffer();

  const std::vector<Layer*>& getOrderedLayers() { return mOrderedLayers; }

 private:
  bool hasConfig(int32_t configId) const;
  DisplayConfig* getConfig(int32_t configId);

  std::optional<int32_t> getBootConfigId();

  void setLegacyEdid();

  // The state of this display should only be modified from
  // SurfaceFlinger's main loop, with the exception of when dump is
  // called. To prevent a bad state from crashing us during a dump
  // call, all public calls into Display must acquire this mutex.
  mutable std::recursive_mutex mStateMutex;

  FrameComposer* mComposer = nullptr;
  const int64_t mId;
  std::string mName;
  PowerMode mPowerMode = PowerMode::OFF;
  VsyncThread mVsyncThread;
  FencedBuffer mClientTarget;
  FencedBuffer mReadbackBuffer;
  // Will only be non-null after the Display has been validated and
  // before it has been accepted.
  enum class PresentFlowState {
    WAITING_FOR_VALIDATE,
    WAITING_FOR_ACCEPT,
    WAITING_FOR_PRESENT,
  };
  PresentFlowState mPresentFlowState = PresentFlowState::WAITING_FOR_VALIDATE;
  DisplayChanges mPendingChanges;
  std::optional<TimePoint> mExpectedPresentTime;
  std::unordered_map<int64_t, std::unique_ptr<Layer>> mLayers;
  // Ordered layers available after validate().
  std::vector<Layer*> mOrderedLayers;
  std::optional<int32_t> mActiveConfigId;
  std::unordered_map<int32_t, DisplayConfig> mConfigs;
  std::unordered_set<ColorMode> mColorModes = {ColorMode::NATIVE};
  ColorMode mActiveColorMode = ColorMode::NATIVE;
  std::optional<std::array<float, 16>> mColorTransform;
  std::vector<uint8_t> mEdid;
};

}  // namespace aidl::android::hardware::graphics::composer3::impl

#endif