// Copyright 2020 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/camera/bin/usb_device/sysmem_allocator.h"

#include <fidl/fuchsia.sysmem2/cpp/hlcpp_conversion.h>
#include <lib/async-loop/default.h>
#include <lib/async/cpp/task.h>
#include <lib/fit/defer.h>
#include <lib/fpromise/bridge.h>
#include <lib/fpromise/scope.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/sysmem-version/sysmem-version.h>

namespace camera {
namespace {

constexpr uint32_t kNamePriority = 30;  // Higher than Scenic but below the maximum.

// Returns a promise that completes after calling |WaitForBuffersAllocated| on the provided
// BufferCollection.
//
// The |collection| is consumed by this operation and will be closed upon both success and failure.
fpromise::promise<BufferCollectionWithLifetime, zx_status_t> WaitForAllBuffersAllocated(
    fuchsia::sysmem2::BufferCollectionPtr collection) {
  // Move the bridge completer into a shared_ptr so that we can share the completer between the
  // FIDL error handler and the WaitForBuffersAllocated callback.
  fpromise::bridge<BufferCollectionWithLifetime, zx_status_t> bridge;
  auto completer = std::make_shared<fpromise::completer<BufferCollectionWithLifetime, zx_status_t>>(
      std::move(bridge.completer));
  std::weak_ptr<fpromise::completer<BufferCollectionWithLifetime, zx_status_t>> weak_completer(
      completer);
  collection.set_error_handler([completer](zx_status_t status) {
    // After calling SetConstraints, allocation may fail. This results in WaitForBuffersAllocated
    // returning NO_MEMORY followed by channel closure. Because the client may observe these in
    // either order, treat channel closure as if it were NO_MEMORY.
    FX_CHECK(status != ZX_OK);
    completer->complete_error(status == ZX_ERR_PEER_CLOSED ? ZX_ERR_NO_MEMORY : status);
  });

  zx::eventpair deallocation_complete_client, deallocation_complete_server;
  zx::eventpair::create(/*options=*/0, &deallocation_complete_client,
                        &deallocation_complete_server);
  fuchsia::sysmem2::BufferCollectionAttachLifetimeTrackingRequest attach_lifetime_request;
  attach_lifetime_request.set_server_end(std::move(deallocation_complete_server));
  attach_lifetime_request.set_buffers_remaining(0);
  collection->AttachLifetimeTracking(std::move(attach_lifetime_request));

  collection->WaitForAllBuffersAllocated(
      [weak_completer, deallocation_complete = std::move(deallocation_complete_client)](
          fuchsia::sysmem2::BufferCollection_WaitForAllBuffersAllocated_Result result) mutable {
        auto completer = weak_completer.lock();
        if (!completer) {
          return;
        }
        if (result.is_framework_err()) {
          completer->complete_error(ZX_ERR_INTERNAL);
          return;
        }
        if (result.is_err()) {
          zx_status_t v1_error = sysmem::V1CopyFromV2Error(fidl::HLCPPToNatural(result.err()));
          completer->complete_error(v1_error);
          return;
        }
        BufferCollectionWithLifetime collection_lifetime;
        collection_lifetime.buffers =
            std::move(*result.response().mutable_buffer_collection_info());
        collection_lifetime.deallocation_complete = std::move(deallocation_complete);
        completer->complete_ok(std::move(collection_lifetime));
      });
  return bridge.consumer.promise().inspect(
      [collection = std::move(collection)](
          const fpromise::result<BufferCollectionWithLifetime, zx_status_t>& result) mutable {
        if (collection) {
          collection->Release();
          collection = nullptr;
        }
      });
}

}  // namespace

SysmemAllocator::SysmemAllocator(fuchsia::sysmem2::AllocatorHandle allocator)
    : allocator_(allocator.Bind()) {}

fpromise::promise<BufferCollectionWithLifetime, zx_status_t> SysmemAllocator::BindSharedCollection(
    fuchsia::sysmem2::BufferCollectionTokenHandle token,
    fuchsia::sysmem2::BufferCollectionConstraints constraints, std::string name) {
  TRACE_DURATION("camera", "SysmemAllocator::BindSharedCollection");
  // We expect sysmem to have free space, so bind the provided token now.
  fuchsia::sysmem2::BufferCollectionPtr collection;

  fuchsia::sysmem2::AllocatorBindSharedCollectionRequest bind_shared_request;
  bind_shared_request.set_token(std::move(token));
  bind_shared_request.set_buffer_collection_request(collection.NewRequest());
  allocator_->BindSharedCollection(std::move(bind_shared_request));

  fuchsia::sysmem2::NodeSetNameRequest set_name_request;
  set_name_request.set_priority(kNamePriority);
  set_name_request.set_name(std::move(name));
  collection->SetName(std::move(set_name_request));

  fuchsia::sysmem2::BufferCollectionSetConstraintsRequest set_constraints_request;
  set_constraints_request.set_constraints(std::move(constraints));
  collection->SetConstraints(std::move(set_constraints_request));

  return WaitForAllBuffersAllocated(std::move(collection)).wrap_with(scope_);
}

}  // namespace camera