// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/graphics/display/drivers/amlogic-display/display-engine.h"

#include <fidl/fuchsia.images2/cpp/wire.h>
#include <fidl/fuchsia.sysmem2/cpp/wire_test_base.h>
#include <fuchsia/hardware/display/controller/c/banjo.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/async/default.h>
#include <lib/async_patterns/testing/cpp/dispatcher_bound.h>
#include <lib/inspect/cpp/inspect.h>

#include <fake-mmio-reg/fake-mmio-reg.h>
#include <gtest/gtest.h>

#include "fidl/fuchsia.images2/cpp/wire_types.h"
#include "fidl/fuchsia.sysmem2/cpp/wire_types.h"
#include "lib/fidl/cpp/wire/arena.h"
#include "src/devices/testing/mock-ddk/mock-device.h"
#include "src/graphics/display/drivers/amlogic-display/pixel-grid-size2d.h"
#include "src/graphics/display/drivers/amlogic-display/video-input-unit.h"
#include "src/graphics/display/lib/api-types-cpp/driver-buffer-collection-id.h"
#include "src/graphics/display/lib/driver-framework-migration-utils/dispatcher/loop-backed-dispatcher-factory.h"
#include "src/graphics/display/lib/driver-framework-migration-utils/metadata/metadata-getter-dfv1.h"
#include "src/graphics/display/lib/driver-framework-migration-utils/metadata/metadata-getter.h"
#include "src/graphics/display/lib/driver-framework-migration-utils/namespace/namespace-dfv1.h"
#include "src/lib/fsl/handles/object_info.h"
#include "src/lib/testing/predicates/status.h"

namespace amlogic_display {

namespace {

// TODO(https://fxbug.dev/42072949): Consider creating and using a unified set of sysmem
// testing doubles instead of writing mocks for each display driver test.
class MockBufferCollectionBase
    : public fidl::testing::WireTestBase<fuchsia_sysmem2::BufferCollection> {
 public:
  MockBufferCollectionBase() = default;
  ~MockBufferCollectionBase() override = default;

  virtual void VerifyBufferCollectionConstraints(
      const fuchsia_sysmem2::wire::BufferCollectionConstraints& constraints) = 0;
  virtual void VerifyName(const std::string& name) = 0;

  void SetConstraints(SetConstraintsRequestView request,
                      SetConstraintsCompleter::Sync& completer) override {
    if (!request->has_constraints()) {
      return;
    }
    VerifyBufferCollectionConstraints(request->constraints());
    set_constraints_called_ = true;
  }

  void SetName(SetNameRequestView request, SetNameCompleter::Sync& completer) override {
    EXPECT_EQ(10u, request->priority());
    VerifyName(std::string(request->name().data(), request->name().size()));
    set_name_called_ = true;
  }

  void CheckAllBuffersAllocated(CheckAllBuffersAllocatedCompleter::Sync& completer) override {
    completer.Reply(fit::ok());
  }

  void WaitForAllBuffersAllocated(WaitForAllBuffersAllocatedCompleter::Sync& completer) override {
    zx::vmo vmo;
    EXPECT_EQ(ZX_OK, zx::vmo::create(ZX_PAGE_SIZE, 0u, &vmo));
    auto collection = fuchsia_sysmem2::wire::BufferCollectionInfo::Builder(arena_)
                          .buffers(std::vector{fuchsia_sysmem2::wire::VmoBuffer::Builder(arena_)
                                                   .vmo(std::move(vmo))
                                                   .vmo_usable_start(0)
                                                   .Build()})
                          .settings(fuchsia_sysmem2::wire::SingleBufferSettings::Builder(arena_)
                                        .image_format_constraints(image_format_constraints_)
                                        .Build())
                          .Build();
    auto response =
        fuchsia_sysmem2::wire::BufferCollectionWaitForAllBuffersAllocatedResponse::Builder(arena_)
            .buffer_collection_info(collection)
            .Build();
    completer.Reply(fit::ok(&response));
  }

  void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
    EXPECT_TRUE(false);
  }

  void set_allocated_image_format_constraints(
      const fuchsia_sysmem2::wire::ImageFormatConstraints& image_format_constraints) {
    image_format_constraints_ = image_format_constraints;
  }
  bool set_constraints_called() const { return set_constraints_called_; }
  bool set_name_called() const { return set_name_called_; }

 private:
  fidl::Arena<fidl::kDefaultArenaInitialCapacity> arena_;
  bool set_constraints_called_ = false;
  bool set_name_called_ = false;
  fuchsia_sysmem2::wire::ImageFormatConstraints image_format_constraints_;
};

class MockBufferCollection : public MockBufferCollectionBase {
 public:
  explicit MockBufferCollection(
      const std::vector<fuchsia_images2::wire::PixelFormat>& pixel_format_types =
          {fuchsia_images2::wire::PixelFormat::kB8G8R8A8,
           fuchsia_images2::wire::PixelFormat::kR8G8B8A8})
      : supported_pixel_format_types_(pixel_format_types) {
    set_allocated_image_format_constraints(
        fuchsia_sysmem2::wire::ImageFormatConstraints::Builder(arena_)
            .pixel_format(fuchsia_images2::wire::PixelFormat::kB8G8R8A8)
            .pixel_format_modifier(fuchsia_images2::wire::PixelFormatModifier::kLinear)
            .min_size(fuchsia_math::wire::SizeU{.width = 1, .height = 4})
            .min_bytes_per_row(4096)
            .Build());
  }
  ~MockBufferCollection() override = default;

  void VerifyBufferCollectionConstraints(
      const fuchsia_sysmem2::wire::BufferCollectionConstraints& constraints) override {
    EXPECT_TRUE(constraints.buffer_memory_constraints().inaccessible_domain_supported());
    EXPECT_FALSE(constraints.buffer_memory_constraints().cpu_domain_supported());
    EXPECT_EQ(64u, constraints.image_format_constraints().at(0).bytes_per_row_divisor());

    size_t expected_format_constraints_count = 0u;
    const cpp20::span<const fuchsia_sysmem2::wire::ImageFormatConstraints> image_format_constraints(
        constraints.image_format_constraints().data(),
        constraints.image_format_constraints().count());

    const bool has_bgra =
        std::find(supported_pixel_format_types_.begin(), supported_pixel_format_types_.end(),
                  fuchsia_images2::wire::PixelFormat::kB8G8R8A8) !=
        supported_pixel_format_types_.end();
    if (has_bgra) {
      expected_format_constraints_count += 2;
      const bool image_constraints_contains_bgra32_and_linear = std::any_of(
          image_format_constraints.begin(), image_format_constraints.end(),
          [](const fuchsia_sysmem2::wire::ImageFormatConstraints& format) {
            return format.pixel_format() == fuchsia_images2::wire::PixelFormat::kB8G8R8A8 &&
                   format.pixel_format_modifier() ==
                       fuchsia_images2::wire::PixelFormatModifier::kLinear;
          });
      EXPECT_TRUE(image_constraints_contains_bgra32_and_linear);
    }

    const bool has_rgba =
        std::find(supported_pixel_format_types_.begin(), supported_pixel_format_types_.end(),
                  fuchsia_images2::wire::PixelFormat::kR8G8B8A8) !=
        supported_pixel_format_types_.end();
    if (has_rgba) {
      expected_format_constraints_count += 4;
      const bool image_constraints_contains_rgba32_and_linear = std::any_of(
          image_format_constraints.begin(), image_format_constraints.end(),
          [](const fuchsia_sysmem2::wire::ImageFormatConstraints& format) {
            return format.pixel_format() == fuchsia_images2::wire::PixelFormat::kR8G8B8A8 &&
                   format.pixel_format_modifier() ==
                       fuchsia_images2::wire::PixelFormatModifier::kLinear;
          });
      EXPECT_TRUE(image_constraints_contains_rgba32_and_linear);
      const bool image_constraints_contains_rgba32_and_afbc_16x16 = std::any_of(
          image_format_constraints.begin(), image_format_constraints.end(),
          [](const fuchsia_sysmem2::wire::ImageFormatConstraints& format) {
            return format.pixel_format() == fuchsia_images2::wire::PixelFormat::kR8G8B8A8 &&
                   format.pixel_format_modifier() ==
                       fuchsia_images2::wire::PixelFormatModifier::kArmAfbc16X16SplitBlockSparseYuv;
          });
      EXPECT_TRUE(image_constraints_contains_rgba32_and_afbc_16x16);
    }

    EXPECT_EQ(expected_format_constraints_count, constraints.image_format_constraints().count());
  }

  void VerifyName(const std::string& name) override { EXPECT_EQ(name, "Display"); }

 private:
  fidl::Arena<fidl::kDefaultArenaInitialCapacity> arena_;
  std::vector<fuchsia_images2::wire::PixelFormat> supported_pixel_format_types_;
};

class MockBufferCollectionForCapture : public MockBufferCollectionBase {
 public:
  MockBufferCollectionForCapture() {
    set_allocated_image_format_constraints(
        fuchsia_sysmem2::wire::ImageFormatConstraints::Builder(arena_)
            .pixel_format(fuchsia_images2::wire::PixelFormat::kB8G8R8)
            .pixel_format_modifier(fuchsia_images2::wire::PixelFormatModifier::kLinear)
            .min_size(fuchsia_math::wire::SizeU{.width = 1, .height = 4})
            .min_bytes_per_row(4096)
            .Build());
  }
  ~MockBufferCollectionForCapture() override = default;

  void VerifyBufferCollectionConstraints(
      const fuchsia_sysmem2::wire::BufferCollectionConstraints& constraints) override {
    EXPECT_TRUE(constraints.buffer_memory_constraints().inaccessible_domain_supported());
    EXPECT_FALSE(constraints.buffer_memory_constraints().cpu_domain_supported());
    EXPECT_EQ(64u, constraints.image_format_constraints().at(0).bytes_per_row_divisor());

    size_t expected_format_constraints_count = 1u;
    EXPECT_EQ(expected_format_constraints_count, constraints.image_format_constraints().count());

    const auto& image_format_constraints = constraints.image_format_constraints();
    EXPECT_EQ(image_format_constraints.at(0).pixel_format(),
              fuchsia_images2::wire::PixelFormat::kB8G8R8);
    EXPECT_TRUE(image_format_constraints.at(0).has_pixel_format_modifier());
    EXPECT_EQ(image_format_constraints.at(0).pixel_format_modifier(),
              fuchsia_images2::wire::PixelFormatModifier::kLinear);
  }

  void VerifyName(const std::string& name) override { EXPECT_EQ(name, "Display capture"); }

 private:
  fidl::Arena<fidl::kDefaultArenaInitialCapacity> arena_;
};

class MockAllocator : public fidl::testing::WireTestBase<fuchsia_sysmem2::Allocator> {
 public:
  using MockBufferCollectionBuilder =
      fit::function<std::unique_ptr<MockBufferCollectionBase>(void)>;

  explicit MockAllocator(async_dispatcher_t* dispatcher) : dispatcher_(dispatcher) {
    ZX_ASSERT(dispatcher_ != nullptr);
  }

  void set_mock_buffer_collection_builder(MockBufferCollectionBuilder builder) {
    mock_buffer_collection_builder_ = std::move(builder);
  }

  void BindSharedCollection(BindSharedCollectionRequestView request,
                            BindSharedCollectionCompleter::Sync& completer) override {
    ZX_ASSERT(mock_buffer_collection_builder_ != nullptr);
    auto buffer_collection_id = next_buffer_collection_id_++;
    active_buffer_collections_[buffer_collection_id] = {
        .token_client = std::move(request->token()),
        .mock_buffer_collection = mock_buffer_collection_builder_(),
    };

    fidl::BindServer(
        dispatcher_, std::move(request->buffer_collection_request()),
        active_buffer_collections_[buffer_collection_id].mock_buffer_collection.get(),
        [this, buffer_collection_id](MockBufferCollectionBase*, fidl::UnbindInfo,
                                     fidl::ServerEnd<fuchsia_sysmem2::BufferCollection>) {
          inactive_buffer_collection_tokens_.push_back(
              std::move(active_buffer_collections_[buffer_collection_id].token_client));
          active_buffer_collections_.erase(buffer_collection_id);
        });
  }

  MockBufferCollectionBase* GetMostRecentBufferCollection() {
    const display::DriverBufferCollectionId most_recent_collection_id(
        next_buffer_collection_id_.value() - 1);
    if (active_buffer_collections_.find(most_recent_collection_id) ==
        active_buffer_collections_.end()) {
      return nullptr;
    }
    return active_buffer_collections_.at(most_recent_collection_id).mock_buffer_collection.get();
  }

  std::vector<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
  GetActiveBufferCollectionTokenClients() const {
    std::vector<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
        unowned_token_clients;
    unowned_token_clients.reserve(active_buffer_collections_.size());

    for (const auto& kv : active_buffer_collections_) {
      unowned_token_clients.push_back(kv.second.token_client);
    }
    return unowned_token_clients;
  }

  std::vector<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
  GetInactiveBufferCollectionTokenClients() const {
    std::vector<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
        unowned_token_clients;
    unowned_token_clients.reserve(inactive_buffer_collection_tokens_.size());

    for (const auto& token : inactive_buffer_collection_tokens_) {
      unowned_token_clients.push_back(token);
    }
    return unowned_token_clients;
  }

  void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
    EXPECT_TRUE(false);
  }

 private:
  struct BufferCollection {
    fidl::ClientEnd<fuchsia_sysmem2::BufferCollectionToken> token_client;
    std::unique_ptr<MockBufferCollectionBase> mock_buffer_collection;
  };

  std::unordered_map<display::DriverBufferCollectionId, BufferCollection>
      active_buffer_collections_;
  std::vector<fidl::ClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
      inactive_buffer_collection_tokens_;

  display::DriverBufferCollectionId next_buffer_collection_id_ =
      display::DriverBufferCollectionId(0);
  MockBufferCollectionBuilder mock_buffer_collection_builder_ = nullptr;

  async_dispatcher_t* dispatcher_ = nullptr;
};

class FakeCanvasProtocol : public fidl::WireServer<fuchsia_hardware_amlogiccanvas::Device> {
 public:
  explicit FakeCanvasProtocol(async_dispatcher_t* dispatcher = nullptr)
      : dispatcher_(dispatcher ? dispatcher : async_get_default_dispatcher()) {}

  void Serve(fidl::ServerEnd<fuchsia_hardware_amlogiccanvas::Device> server_end) {
    binding_.emplace(dispatcher_, std::move(server_end), this,
                     std::mem_fn(&FakeCanvasProtocol::OnFidlClosed));
  }

  void OnFidlClosed(fidl::UnbindInfo info) {}

  void Config(ConfigRequestView request, ConfigCompleter::Sync& completer) override {
    for (size_t i = 0; i < std::size(in_use_); i++) {
      ZX_DEBUG_ASSERT_MSG(i <= std::numeric_limits<uint8_t>::max(), "%zu", i);
      if (!in_use_[i]) {
        in_use_[i] = true;
        completer.ReplySuccess(static_cast<uint8_t>(i));
        return;
      }
    }
    completer.ReplyError(ZX_ERR_NO_MEMORY);
  }

  void Free(FreeRequestView request, FreeCompleter::Sync& completer) override {
    EXPECT_TRUE(in_use_[request->canvas_idx]);
    in_use_[request->canvas_idx] = false;
    completer.ReplySuccess();
  }

  void CheckThatNoEntriesInUse() {
    for (uint32_t i = 0; i < std::size(in_use_); i++) {
      EXPECT_FALSE(in_use_[i]);
    }
  }

 private:
  async_dispatcher_t* dispatcher_;
  static constexpr uint32_t kCanvasEntries = 256;
  bool in_use_[kCanvasEntries] = {};
  std::optional<fidl::ServerBinding<fuchsia_hardware_amlogiccanvas::Device>> binding_;
};

class FakeSysmemTest : public testing::Test {
 public:
  static constexpr int kWidth = 1024;
  static constexpr int kHeight = 600;

  FakeSysmemTest() : loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {}

  void SetUp() override {
    mock_root_ = MockDevice::FakeRootParent();

    loop_.StartThread("sysmem-handler-loop");
    auto endpoints = fidl::Endpoints<fuchsia_hardware_amlogiccanvas::Device>::Create();
    canvas_.SyncCall(&FakeCanvasProtocol::Serve, std::move(endpoints.server));

    zx::result<std::unique_ptr<display::Namespace>> create_incoming_result =
        display::NamespaceDfv1::Create(mock_root_.get());
    ASSERT_OK(create_incoming_result.status_value());
    incoming_ = std::move(create_incoming_result).value();

    zx::result<std::unique_ptr<display::MetadataGetter>> create_metadata_getter_result =
        display::MetadataGetterDfv1::Create(mock_root_.get());
    ASSERT_OK(create_metadata_getter_result.status_value());
    metadata_getter_ = std::move(create_metadata_getter_result).value();

    zx::result<std::unique_ptr<display::DispatcherFactory>> create_dispatcher_factory_result =
        display::LoopBackedDispatcherFactory::Create(mock_root_.get());
    ASSERT_OK(create_dispatcher_factory_result.status_value());
    dispatcher_factory_ = std::move(create_dispatcher_factory_result).value();

    display_engine_ = std::make_unique<DisplayEngine>(incoming_.get(), metadata_getter_.get(),
                                                      dispatcher_factory_.get());
    display_engine_->SetFormatSupportCheck([](auto) { return true; });
    display_engine_->SetCanvasForTesting(std::move(endpoints.client));

    zx::result<std::unique_ptr<Vout>> create_dsi_vout_result = Vout::CreateDsiVoutForTesting(
        /*panel_type=*/PANEL_BOE_TV070WSM_FITIPOWER_JD9364_ASTRO, /*width=*/kWidth,
        /*height=*/kHeight);
    ASSERT_OK(create_dsi_vout_result.status_value());
    display_engine_->SetVoutForTesting(std::move(create_dsi_vout_result).value());

    PixelGridSize2D layer_image_size = {
        .width = kWidth,
        .height = kHeight,
    };
    PixelGridSize2D display_contents_size = {
        .width = kWidth,
        .height = kHeight,
    };
    zx::result<std::unique_ptr<VideoInputUnit>> video_input_unit_result =
        VideoInputUnit::CreateForTesting(vpu_mmio_.GetMmioBuffer(), /*rdma=*/nullptr,
                                         layer_image_size, display_contents_size);
    ASSERT_OK(video_input_unit_result.status_value());
    display_engine_->SetVideoInputUnitForTesting(std::move(video_input_unit_result).value());

    allocator_ = std::make_unique<MockAllocator>(loop_.dispatcher());
    allocator_->set_mock_buffer_collection_builder([] {
      // Allocate importable primary Image by default.
      const std::vector<fuchsia_images2::wire::PixelFormat> kPixelFormats = {
          fuchsia_images2::wire::PixelFormat::kB8G8R8A8,
          fuchsia_images2::wire::PixelFormat::kR8G8B8A8};
      return std::make_unique<MockBufferCollection>(kPixelFormats);
    });

    {
      auto endpoints = fidl::Endpoints<fuchsia_sysmem2::Allocator>::Create();
      fidl::BindServer(loop_.dispatcher(), std::move(endpoints.server), allocator_.get());
      display_engine_->SetSysmemAllocatorForTesting(
          fidl::WireSyncClient(std::move(endpoints.client)));
    }
  }

  void TearDown() override {
    // Shutdown the loop before destroying the MockAllocator which may still have
    // pending callbacks.
    loop_.Shutdown();
    loop_.JoinThreads();
  }

 protected:
  std::shared_ptr<MockDevice> mock_root_;
  async::Loop loop_;

  std::unique_ptr<display::Namespace> incoming_;
  std::unique_ptr<display::MetadataGetter> metadata_getter_;
  std::unique_ptr<display::DispatcherFactory> dispatcher_factory_;

  ddk_fake::FakeMmioRegRegion vpu_mmio_ =
      ddk_fake::FakeMmioRegRegion(/*reg_size=*/4, /*reg_count=*/0x10000);
  std::unique_ptr<DisplayEngine> display_engine_;
  std::unique_ptr<MockAllocator> allocator_;
  async_patterns::TestDispatcherBound<FakeCanvasProtocol> canvas_{loop_.dispatcher(),
                                                                  std::in_place};
};

template <typename Lambda>
bool PollUntil(Lambda predicate, zx::duration poll_interval, int max_intervals) {
  ZX_ASSERT(max_intervals >= 0);

  for (int sleeps_left = max_intervals; sleeps_left > 0; --sleeps_left) {
    if (predicate())
      return true;
    zx::nanosleep(zx::deadline_after(poll_interval));
  }

  return predicate();
}

TEST_F(FakeSysmemTest, ImportBufferCollection) {
  zx::result<fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>> token1_endpoints =
      fidl::CreateEndpoints<fuchsia_sysmem2::BufferCollectionToken>();
  ASSERT_OK(token1_endpoints.status_value());
  zx::result<fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>> token2_endpoints =
      fidl::CreateEndpoints<fuchsia_sysmem2::BufferCollectionToken>();
  ASSERT_OK(token2_endpoints.status_value());

  // Test ImportBufferCollection().
  constexpr display::DriverBufferCollectionId kValidBufferCollectionId(1);
  constexpr uint64_t kBanjoValidBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kValidBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoValidBufferCollectionId, token1_endpoints->client.TakeChannel()));

  // `driver_buffer_collection_id` must be unused.
  EXPECT_EQ(display_engine_->DisplayControllerImplImportBufferCollection(
                kBanjoValidBufferCollectionId, token2_endpoints->client.TakeChannel()),
            ZX_ERR_ALREADY_EXISTS);

  EXPECT_TRUE(
      PollUntil([&]() { return !allocator_->GetActiveBufferCollectionTokenClients().empty(); },
                zx::msec(5), 1000));

  // Verify that the current buffer collection token is used (active).
  {
    auto active_buffer_token_clients = allocator_->GetActiveBufferCollectionTokenClients();
    EXPECT_EQ(active_buffer_token_clients.size(), 1u);

    auto inactive_buffer_token_clients = allocator_->GetInactiveBufferCollectionTokenClients();
    EXPECT_EQ(inactive_buffer_token_clients.size(), 0u);

    auto [client_koid, client_related_koid] =
        fsl::GetKoids(active_buffer_token_clients[0].channel()->get());
    auto [server_koid, server_related_koid] =
        fsl::GetKoids(token1_endpoints->server.channel().get());

    EXPECT_NE(client_koid, ZX_KOID_INVALID);
    EXPECT_NE(client_related_koid, ZX_KOID_INVALID);
    EXPECT_NE(server_koid, ZX_KOID_INVALID);
    EXPECT_NE(server_related_koid, ZX_KOID_INVALID);

    EXPECT_EQ(client_koid, server_related_koid);
    EXPECT_EQ(server_koid, client_related_koid);
  }

  // Test ReleaseBufferCollection().
  constexpr display::DriverBufferCollectionId kInvalidBufferCollectionId(2);
  constexpr uint64_t kBanjoInvalidBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kInvalidBufferCollectionId);
  EXPECT_EQ(display_engine_->DisplayControllerImplReleaseBufferCollection(
                kBanjoInvalidBufferCollectionId),
            ZX_ERR_NOT_FOUND);
  EXPECT_OK(
      display_engine_->DisplayControllerImplReleaseBufferCollection(kBanjoValidBufferCollectionId));

  EXPECT_TRUE(
      PollUntil([&]() { return allocator_->GetActiveBufferCollectionTokenClients().empty(); },
                zx::msec(5), 1000));

  // Verify that the current buffer collection token is released (inactive).
  {
    auto active_buffer_token_clients = allocator_->GetActiveBufferCollectionTokenClients();
    EXPECT_EQ(active_buffer_token_clients.size(), 0u);

    auto inactive_buffer_token_clients = allocator_->GetInactiveBufferCollectionTokenClients();
    EXPECT_EQ(inactive_buffer_token_clients.size(), 1u);

    auto [client_koid, client_related_koid] =
        fsl::GetKoids(inactive_buffer_token_clients[0].channel()->get());
    auto [server_koid, server_related_koid] =
        fsl::GetKoids(token1_endpoints->server.channel().get());

    EXPECT_NE(client_koid, ZX_KOID_INVALID);
    EXPECT_NE(client_related_koid, ZX_KOID_INVALID);
    EXPECT_NE(server_koid, ZX_KOID_INVALID);
    EXPECT_NE(server_related_koid, ZX_KOID_INVALID);

    EXPECT_EQ(client_koid, server_related_koid);
    EXPECT_EQ(server_koid, client_related_koid);
  }
}

TEST_F(FakeSysmemTest, ImportImage) {
  auto [token_client, token_server] =
      fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();

  constexpr display::DriverBufferCollectionId kBufferCollectionId(1);
  constexpr uint64_t kBanjoBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoBufferCollectionId, token_client.TakeChannel()));

  static constexpr image_buffer_usage_t kDisplayUsage = {
      .tiling_type = IMAGE_TILING_TYPE_LINEAR,
  };
  EXPECT_OK(display_engine_->DisplayControllerImplSetBufferCollectionConstraints(
      &kDisplayUsage, kBanjoBufferCollectionId));

  constexpr display::DriverBufferCollectionId kInvalidBufferCollectionId(100);
  constexpr uint64_t kBanjoInvalidBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kInvalidBufferCollectionId);
  EXPECT_EQ(display_engine_->DisplayControllerImplSetBufferCollectionConstraints(
                &kDisplayUsage, kBanjoInvalidBufferCollectionId),
            ZX_ERR_NOT_FOUND);

  // Invalid import: Bad image type.
  static constexpr image_metadata_t kInvalidTilingMetadata = {
      .width = 1024,
      .height = 768,
      .tiling_type = IMAGE_TILING_TYPE_CAPTURE,
  };
  uint64_t image_handle = 0;
  EXPECT_EQ(display_engine_->DisplayControllerImplImportImage(&kInvalidTilingMetadata,
                                                              kBanjoBufferCollectionId,
                                                              /*index=*/0, &image_handle),
            ZX_ERR_INVALID_ARGS);

  // Invalid import: Invalid collection ID.
  static constexpr image_metadata_t kDisplayImageMetadata = {
      .width = 1024,
      .height = 768,
      .tiling_type = IMAGE_TILING_TYPE_LINEAR,
  };
  EXPECT_EQ(display_engine_->DisplayControllerImplImportImage(&kDisplayImageMetadata,
                                                              kBanjoInvalidBufferCollectionId,
                                                              /*index=*/0, &image_handle),
            ZX_ERR_NOT_FOUND);

  // Invalid import: Invalid buffer collection index.
  constexpr uint64_t kInvalidBufferCollectionIndex = 100u;
  image_handle = 0;
  EXPECT_EQ(display_engine_->DisplayControllerImplImportImage(
                &kDisplayImageMetadata, kBanjoBufferCollectionId, kInvalidBufferCollectionIndex,
                &image_handle),
            ZX_ERR_OUT_OF_RANGE);

  // Valid import.
  EXPECT_OK(display_engine_->DisplayControllerImplImportImage(&kDisplayImageMetadata,
                                                              kBanjoBufferCollectionId,
                                                              /*index=*/0, &image_handle));
  EXPECT_NE(image_handle, 0u);

  // Release the image.
  display_engine_->DisplayControllerImplReleaseImage(image_handle);

  EXPECT_OK(
      display_engine_->DisplayControllerImplReleaseBufferCollection(kBanjoBufferCollectionId));
}

TEST_F(FakeSysmemTest, ImportImageForCapture) {
  allocator_->set_mock_buffer_collection_builder(
      [] { return std::make_unique<MockBufferCollectionForCapture>(); });

  auto [token_client, token_server] =
      fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();

  constexpr display::DriverBufferCollectionId kBufferCollectionId(1);
  constexpr uint64_t kBanjoBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoBufferCollectionId, token_client.TakeChannel()));

  // Driver sets BufferCollection buffer memory constraints.
  static constexpr image_buffer_usage_t kCaptureUsage = {
      .tiling_type = IMAGE_TILING_TYPE_CAPTURE,
  };
  EXPECT_OK(display_engine_->DisplayControllerImplSetBufferCollectionConstraints(
      &kCaptureUsage, kBanjoBufferCollectionId));

  // Invalid import: invalid buffer collection ID.
  uint64_t capture_handle = 0;
  const uint64_t kBanjoInvalidBufferCollectionId = 100;
  EXPECT_EQ(
      display_engine_->DisplayControllerImplImportImageForCapture(kBanjoInvalidBufferCollectionId,
                                                                  /*index=*/0, &capture_handle),
      ZX_ERR_NOT_FOUND);

  // Invalid import: index out of range.
  const uint64_t kInvalidIndex = 100;
  EXPECT_EQ(display_engine_->DisplayControllerImplImportImageForCapture(
                kBanjoBufferCollectionId, kInvalidIndex, &capture_handle),
            ZX_ERR_OUT_OF_RANGE);

  // Valid import.
  capture_handle = 0;
  EXPECT_OK(display_engine_->DisplayControllerImplImportImageForCapture(kBanjoBufferCollectionId,
                                                                        /*index=*/0,
                                                                        &capture_handle));
  EXPECT_NE(capture_handle, 0u);

  // Release the image.
  display_engine_->DisplayControllerImplReleaseCapture(capture_handle);

  EXPECT_OK(
      display_engine_->DisplayControllerImplReleaseBufferCollection(kBanjoBufferCollectionId));
}

TEST_F(FakeSysmemTest, SysmemRequirements) {
  MockBufferCollectionBase* collection = nullptr;
  allocator_->set_mock_buffer_collection_builder([&collection] {
    const std::vector<fuchsia_images2::wire::PixelFormat> kPixelFormats = {
        fuchsia_images2::wire::PixelFormat::kB8G8R8A8,
        fuchsia_images2::wire::PixelFormat::kR8G8B8A8};
    auto new_buffer_collection = std::make_unique<MockBufferCollection>(kPixelFormats);
    collection = new_buffer_collection.get();
    return new_buffer_collection;
  });

  auto [token_client, token_server] =
      fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();

  constexpr display::DriverBufferCollectionId kBufferCollectionId(1);
  constexpr uint64_t kBanjoBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoBufferCollectionId, token_client.TakeChannel()));

  EXPECT_TRUE(PollUntil([&] { return collection != nullptr; }, zx::msec(5), 1000));

  static constexpr image_buffer_usage_t kDisplayUsage = {
      .tiling_type = IMAGE_TILING_TYPE_LINEAR,
  };
  EXPECT_OK(display_engine_->DisplayControllerImplSetBufferCollectionConstraints(
      &kDisplayUsage, kBanjoBufferCollectionId));

  EXPECT_TRUE(PollUntil([&] { return collection->set_constraints_called(); }, zx::msec(5), 1000));
  EXPECT_TRUE(collection->set_name_called());
}

TEST_F(FakeSysmemTest, SysmemRequirements_BgraOnly) {
  MockBufferCollectionBase* collection = nullptr;
  allocator_->set_mock_buffer_collection_builder([&collection] {
    const std::vector<fuchsia_images2::wire::PixelFormat> kPixelFormats = {
        fuchsia_images2::wire::PixelFormat::kB8G8R8A8,
    };
    auto new_buffer_collection = std::make_unique<MockBufferCollection>(kPixelFormats);
    collection = new_buffer_collection.get();
    return new_buffer_collection;
  });
  display_engine_->SetFormatSupportCheck([](fuchsia_images2::wire::PixelFormat format) {
    return format == fuchsia_images2::wire::PixelFormat::kB8G8R8A8;
  });

  auto [token_client, token_server] =
      fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();

  constexpr display::DriverBufferCollectionId kBufferCollectionId(1);
  constexpr uint64_t kBanjoBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoBufferCollectionId, token_client.TakeChannel()));

  EXPECT_TRUE(PollUntil([&] { return collection != nullptr; }, zx::msec(5), 1000));

  static constexpr image_buffer_usage_t kDisplayUsage = {
      .tiling_type = IMAGE_TILING_TYPE_LINEAR,
  };
  EXPECT_OK(display_engine_->DisplayControllerImplSetBufferCollectionConstraints(
      &kDisplayUsage, kBanjoBufferCollectionId));

  EXPECT_TRUE(PollUntil([&] { return collection->set_constraints_called(); }, zx::msec(5), 1000));
  EXPECT_TRUE(collection->set_name_called());
}

TEST(AmlogicDisplay, FloatToFix3_10) {
  inspect::Inspector inspector;
  EXPECT_EQ(0x0000u, VideoInputUnit::FloatToFixed3_10(0.0f));
  EXPECT_EQ(0x0066u, VideoInputUnit::FloatToFixed3_10(0.1f));
  EXPECT_EQ(0x1f9au, VideoInputUnit::FloatToFixed3_10(-0.1f));
  // Test for maximum positive (<4)
  EXPECT_EQ(0x0FFFu, VideoInputUnit::FloatToFixed3_10(4.0f));
  EXPECT_EQ(0x0FFFu, VideoInputUnit::FloatToFixed3_10(40.0f));
  EXPECT_EQ(0x0FFFu, VideoInputUnit::FloatToFixed3_10(3.9999f));
  // Test for minimum negative (>= -4)
  EXPECT_EQ(0x1000u, VideoInputUnit::FloatToFixed3_10(-4.0f));
  EXPECT_EQ(0x1000u, VideoInputUnit::FloatToFixed3_10(-14.0f));
}

TEST(AmlogicDisplay, FloatToFixed2_10) {
  inspect::Inspector inspector;
  EXPECT_EQ(0x0000u, VideoInputUnit::FloatToFixed2_10(0.0f));
  EXPECT_EQ(0x0066u, VideoInputUnit::FloatToFixed2_10(0.1f));
  EXPECT_EQ(0x0f9au, VideoInputUnit::FloatToFixed2_10(-0.1f));
  // Test for maximum positive (<2)
  EXPECT_EQ(0x07FFu, VideoInputUnit::FloatToFixed2_10(2.0f));
  EXPECT_EQ(0x07FFu, VideoInputUnit::FloatToFixed2_10(20.0f));
  EXPECT_EQ(0x07FFu, VideoInputUnit::FloatToFixed2_10(1.9999f));
  // Test for minimum negative (>= -2)
  EXPECT_EQ(0x0800u, VideoInputUnit::FloatToFixed2_10(-2.0f));
  EXPECT_EQ(0x0800u, VideoInputUnit::FloatToFixed2_10(-14.0f));
}

TEST_F(FakeSysmemTest, NoLeakCaptureCanvas) {
  allocator_->set_mock_buffer_collection_builder(
      [] { return std::make_unique<MockBufferCollectionForCapture>(); });

  auto [token_client, token_server] =
      fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();

  constexpr display::DriverBufferCollectionId kBufferCollectionId(1);
  constexpr uint64_t kBanjoBufferCollectionId =
      display::ToBanjoDriverBufferCollectionId(kBufferCollectionId);
  EXPECT_OK(display_engine_->DisplayControllerImplImportBufferCollection(
      kBanjoBufferCollectionId, token_client.TakeChannel()));

  uint64_t capture_handle;
  EXPECT_OK(display_engine_->DisplayControllerImplImportImageForCapture(kBanjoBufferCollectionId,
                                                                        /*index=*/0,
                                                                        &capture_handle));
  EXPECT_OK(display_engine_->DisplayControllerImplReleaseCapture(capture_handle));

  canvas_.SyncCall(&FakeCanvasProtocol::CheckThatNoEntriesInUse);
}

}  // namespace

}  // namespace amlogic_display