// Copyright 2022 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 <lib/fidl/cpp/natural_encoder.h>
#include <lib/fidl/txn_header.h>
#include <zircon/assert.h>
#include <zircon/fidl.h>

namespace fidl::internal {

void ptr_noop(void*) {}

namespace {

const size_t kSmallAllocSize = 512;
const size_t kLargeAllocSize = ZX_CHANNEL_MAX_MSG_BYTES;

size_t Align(size_t size) {
  constexpr size_t alignment_mask = FIDL_ALIGNMENT - 1;
  return (size + alignment_mask) & ~alignment_mask;
}

}  // namespace

NaturalEncoder::NaturalEncoder(const CodingConfig* coding_config) : coding_config_(coding_config) {}

NaturalEncoder::NaturalEncoder(const CodingConfig* coding_config,
                               internal::WireFormatVersion wire_format)
    : coding_config_(coding_config), wire_format_(wire_format) {}

size_t NaturalEncoder::Alloc(size_t size) {
  size_t offset = bytes_.size();
  size_t new_size = bytes_.size() + Align(size);

  if (likely(new_size <= kSmallAllocSize)) {
    bytes_.reserve(kSmallAllocSize);
  } else if (likely(new_size <= kLargeAllocSize)) {
    bytes_.reserve(kLargeAllocSize);
  } else {
    bytes_.reserve(new_size);
  }
  bytes_.resize(new_size);

  return offset;
}

void NaturalEncoder::EncodeHandle(fidl_handle_t handle, HandleAttributes attr, size_t offset,
                                  bool is_optional) {
  if (handle) {
    *GetPtr<zx_handle_t>(offset) = FIDL_HANDLE_PRESENT;

    if (handle_actual_ >= std::size(handles_)) {
      SetError(kCodingErrorTooManyHandlesConsumed);
      coding_config_->close(handle);
      return;
    }
    handles_[handle_actual_] = handle;

    if (coding_config_->encode_process_handle) {
      if (handle_metadata_ == nullptr && coding_config_->handle_metadata_stride != 0) {
        handle_metadata_ = MallocedUniquePtr(
            malloc(ZX_CHANNEL_MAX_MSG_HANDLES * coding_config_->handle_metadata_stride), free);
      }

      const char* error;
      zx_status_t status = coding_config_->encode_process_handle(attr, handle_actual_,
                                                                 handle_metadata_.get(), &error);
      ZX_ASSERT_MSG(ZX_OK == status, "error in encode_process_handle: %s", error);
    }

    handle_actual_++;
  } else {
    if (!is_optional) {
      SetError(kCodingErrorAbsentNonNullableHandle);
      return;
    }
    *GetPtr<zx_handle_t>(offset) = FIDL_HANDLE_ABSENT;
  }
}

NaturalBodyEncoder::~NaturalBodyEncoder() { Reset(); }

fidl::OutgoingMessage NaturalBodyEncoder::GetOutgoingMessage(MessageType type) {
  if (status_ != ZX_OK) {
    Reset();
    return fidl::OutgoingMessage(fidl::Status::EncodeError(status_, error_));
  }

  uint32_t num_handles = handle_actual_;
  handle_actual_ = 0;
  iovec_ = {
      .buffer = bytes_.data(),
      .capacity = static_cast<uint32_t>(bytes_.size()),
  };
  return fidl::OutgoingMessage::Create_InternalMayBreak({
      .transport_vtable = vtable_,
      .iovecs = &iovec_,
      .num_iovecs = 1,
      .handles = handles_,
      .handle_metadata = static_cast<fidl_handle_metadata_t*>(handle_metadata_.get()),
      .num_handles = num_handles,
      .is_transactional = type == MessageType::kTransactional,
  });
}

void NaturalBodyEncoder::Reset() {
  bytes_.clear();
  vtable_->encoding_configuration->close_many(handles_, handle_actual_);
  handle_metadata_.reset();
  handle_actual_ = 0;
}

}  // namespace fidl::internal