// 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 "bt_transport_uart.h"

#include <assert.h>
#include <lib/async/default.h>
#include <lib/ddk/metadata.h>
#include <lib/driver/component/cpp/driver_export.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <threads.h>
#include <unistd.h>
#include <zircon/assert.h>
#include <zircon/status.h>

namespace bt_transport_uart {

BtTransportUart::BtTransportUart(fuchsia_driver_framework::DriverStartArgs start_args,
                                 fdf::UnownedSynchronizedDispatcher driver_dispatcher)
    : DriverBase("bt-transport-uart", std::move(start_args), std::move(driver_dispatcher)),
      dispatcher_(dispatcher()),
      node_(fidl::WireClient(std::move(node()), dispatcher())) {}

zx::result<> BtTransportUart::Start() {
  FDF_LOG(DEBUG, "Start");

  zx::result<fdf::ClientEnd<fuchsia_hardware_serialimpl::Device>> client_end =
      incoming()->Connect<fuchsia_hardware_serialimpl::Service::Device>();
  if (client_end.is_error()) {
    FDF_LOG(ERROR, "Connect to fuchsia_hardware_serialimpl::Device protocol failed: %s",
            client_end.status_string());
    return zx::error(client_end.status_value());
  }

  {
    std::lock_guard guard(mutex_);

    serial_client_ = fdf::WireClient<fuchsia_hardware_serialimpl::Device>(
        std::move(client_end.value()), driver_dispatcher()->get());
    if (!serial_client_.is_valid()) {
      FDF_LOG(ERROR, "fuchsia_hardware_serialimpl::Device Client is not valid");
      return zx::error(ZX_ERR_BAD_HANDLE);
    }

    // pre-populate event packet indicators
    event_buffer_[0] = kHciEvent;
    event_buffer_offset_ = 1;
    acl_buffer_[0] = kHciAclData;
    acl_buffer_offset_ = 1;
    sco_buffer_[0] = kHciSco;
    sco_buffer_offset_ = 1;
  }

  fdf::Arena arena('INIT');
  auto info_result = serial_client_.sync().buffer(arena)->GetInfo();
  if (!info_result.ok()) {
    FDF_LOG(ERROR, "hci_start: GetInfo failed with FIDL error %s", info_result.status_string());
    return zx::error(info_result.status());
  }
  if (info_result->is_error()) {
    FDF_LOG(ERROR, "hci_start: GetInfo failed with error %s",
            zx_status_get_string(info_result->error_value()));
    return zx::error(info_result->error_value());
  }

  if (info_result.value()->info.serial_class != fuchsia_hardware_serial::Class::kBluetoothHci) {
    FDF_LOG(ERROR, "hci_start: device class isn't BLUETOOTH_HCI");
    return zx::error(ZX_ERR_INTERNAL);
  }

  serial_pid_ = info_result.value()->info.serial_pid;

  auto enable_result = serial_client_.sync().buffer(arena)->Enable(true);
  if (!enable_result.ok()) {
    FDF_LOG(ERROR, "hci_start: Enable failed with FIDL error %s", enable_result.status_string());
    return zx::error(enable_result.status());
  }

  if (enable_result->is_error()) {
    FDF_LOG(ERROR, "hci_start: Enable failed with error %s",
            zx_status_get_string(enable_result->error_value()));
    return zx::error(enable_result->error_value());
  }

  queue_read_task_.Post(dispatcher_);

  zx_status_t status = ServeProtocols();
  if (status != ZX_OK) {
    FDF_LOG(ERROR, "Failed to serve protocols: %s", zx_status_get_string(status));
    return zx::error(status);
  }

  // Start compat device server to forward metadata.
  zx::result compat_server_result =
      compat_server_.Initialize(incoming(), outgoing(), node_name(), "bt-transport-uart",
                                compat::ForwardMetadata::Some({DEVICE_METADATA_MAC_ADDRESS}));
  if (compat_server_result.is_error()) {
    FDF_LOG(ERROR, "Failed to initialize device server: %s", compat_server_result.status_string());
    return compat_server_result.take_error();
  }

  // Add child node for the vendor driver to bind.
  fidl::Arena args_arena;

  // Build offers
  auto offers = compat_server_.CreateOffers2(args_arena);
  offers.push_back(fdf::MakeOffer2<fuchsia_hardware_bluetooth::HciService>(args_arena));
  offers.push_back(fdf::MakeOffer2<fuchsia_hardware_serialimpl::Service>(args_arena));

  auto args = fuchsia_driver_framework::wire::NodeAddArgs::Builder(args_arena)
                  .name("bt-transport-uart")
                  .offers2(std::move(offers))
                  .Build();

  auto controller_endpoints = fidl::CreateEndpoints<fuchsia_driver_framework::NodeController>();
  if (controller_endpoints.is_error()) {
    FDF_LOG(ERROR, "Create node controller end points failed: %s",
            zx_status_get_string(controller_endpoints.error_value()));
    return zx::error(controller_endpoints.error_value());
  }

  // Add bt-transport-uart child node.
  auto result =
      node_.sync()->AddChild(std::move(args), std::move(controller_endpoints->server), {});
  if (!result.ok()) {
    FDF_LOG(ERROR, "Failed to add bt-transport-uart node, FIDL error: %s", result.status_string());
    return zx::error(result.status());
  }

  if (result->is_error()) {
    FDF_LOG(ERROR, "Failed to add bt-transport-uart node: %u",
            static_cast<uint32_t>(result->error_value()));
    return zx::error(ZX_ERR_INTERNAL);
  }

  node_controller_.Bind(std::move(controller_endpoints->client), dispatcher(), this);

  return zx::ok();
}

void BtTransportUart::PrepareStop(fdf::PrepareStopCompleter completer) {
  FDF_LOG(TRACE, "Unbind");

  // We are now shutting down.  Make sure that any pending callbacks in
  // flight from the serial_impl are nerfed and that our thread is shut down.
  std::atomic_store_explicit(&shutting_down_, true, std::memory_order_relaxed);

  {
    std::lock_guard guard(mutex_);

    // Close the transport channels so that the host stack is notified of device
    // removal and tasks aren't posted to work thread.
    ChannelCleanupLocked(&cmd_channel_);
    ChannelCleanupLocked(&acl_channel_);
    ChannelCleanupLocked(&sco_channel_);
    ChannelCleanupLocked(&snoop_channel_);
  }

  // Finish by making sure that all in flight transactions transactions have
  // been canceled.
  fdf::Arena arena('CANC');
  auto result = serial_client_.sync().buffer(arena)->CancelAll();
  if (!result.ok()) {
    FDF_LOG(ERROR, "hci_bind: CancelAll failed with FIDL error %s", result.status_string());
    completer(zx::error(result.status()));
  }

  FDF_LOG(TRACE, "PrepareStop complete");

  completer(zx::ok());
}

// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
BtTransportUart::Wait::Wait(BtTransportUart* uart, zx::channel* channel) {
  this->state = ASYNC_STATE_INIT;
  this->handler = Handler;
  this->object = ZX_HANDLE_INVALID;
  this->trigger = ZX_SIGNAL_NONE;
  this->options = 0;
  this->uart = uart;
  this->channel = channel;
}

void BtTransportUart::Wait::Handler(async_dispatcher_t* dispatcher, async_wait_t* async_wait,
                                    zx_status_t status, const zx_packet_signal_t* signal) {
  auto wait = static_cast<Wait*>(async_wait);
  wait->uart->OnChannelSignal(wait, status, signal);
}

size_t BtTransportUart::EventPacketLength() {
  // payload length is in byte 2 of the packet
  // add 3 bytes for packet indicator, event code and length byte
  return event_buffer_offset_ > 2 ? event_buffer_[2] + 3 : 0;
}

size_t BtTransportUart::AclPacketLength() {
  // length is in bytes 3 and 4 of the packet
  // add 5 bytes for packet indicator, control info and length fields
  return acl_buffer_offset_ > 4 ? (acl_buffer_[3] | (acl_buffer_[4] << 8)) + 5 : 0;
}

size_t BtTransportUart::ScoPacketLength() {
  // payload length is byte 3 of the packet
  // add 4 bytes for packet indicator, handle, and length byte
  return sco_buffer_offset_ > 3 ? (sco_buffer_[3] + 4) : 0;
}

void BtTransportUart::ChannelCleanupLocked(zx::channel* channel) {
  if (!channel->is_valid()) {
    return;
  }

  if (channel == &cmd_channel_ && cmd_channel_wait_.pending) {
    async_cancel_wait(dispatcher_, &cmd_channel_wait_);
    cmd_channel_wait_.pending = false;
  } else if (channel == &acl_channel_ && acl_channel_wait_.pending) {
    async_cancel_wait(dispatcher_, &acl_channel_wait_);
    acl_channel_wait_.pending = false;
  } else if (channel == &sco_channel_ && sco_channel_wait_.pending) {
    async_cancel_wait(dispatcher_, &sco_channel_wait_);
    sco_channel_wait_.pending = false;
  }
  channel->reset();
}

void BtTransportUart::SnoopChannelWriteLocked(uint8_t flags, uint8_t* bytes, size_t length) {
  if (!snoop_channel_.is_valid()) {
    return;
  }

  // We tack on a flags byte to the beginning of the payload.
  // Use an iovec to avoid a large allocation + copy.
  zx_channel_iovec_t iovs[2];
  iovs[0] = {.buffer = &flags, .capacity = sizeof(flags), .reserved = 0};
  iovs[1] = {.buffer = bytes, .capacity = static_cast<uint32_t>(length), .reserved = 0};

  zx_status_t status =
      snoop_channel_.write(/*flags=*/ZX_CHANNEL_WRITE_USE_IOVEC, /*bytes=*/iovs,
                           /*num_bytes=*/std::size(iovs), /*handles=*/nullptr, /*num_handles=*/0);

  if (status != ZX_OK) {
    if (status != ZX_ERR_PEER_CLOSED) {
      FDF_LOG(ERROR, "bt-transport-uart: failed to write to snoop channel: %s",
              zx_status_get_string(status));
    }

    // It should be safe to clean up the channel right here as the work thread
    // never waits on this channel from outside of the lock.
    ChannelCleanupLocked(&snoop_channel_);
  }
}

void BtTransportUart::HciBeginShutdown() {
  bool was_shutting_down = shutting_down_.exchange(true, std::memory_order_relaxed);
  if (!was_shutting_down) {
    auto result = node_.UnbindMaybeGetEndpoint();
  }
}

void BtTransportUart::SerialWrite(uint8_t* buffer, size_t length) {
  {
    std::lock_guard guard(mutex_);
    ZX_DEBUG_ASSERT(can_write_);
    // Clear the can_write flag.  The UART can currently only handle one in flight
    // transaction at a time.
    can_write_ = false;
  }

  fdf::Arena arena('WRIT');
  auto data = fidl::VectorView<uint8_t>::FromExternal(buffer, length);
  serial_client_.buffer(arena)->Write(data).ThenExactlyOnce(
      [this](fdf::WireUnownedResult<fuchsia_hardware_serialimpl::Device::Write>& result) mutable {
        if (!result.ok()) {
          FDF_LOG(ERROR, "hci_bind: Write failed with FIDL error %s", result.status_string());
          HciWriteComplete(result.status());
          return;
        }

        if (result->is_error()) {
          FDF_LOG(ERROR, "hci_bind: Write failed with error %s",
                  zx_status_get_string(result->error_value()));
          HciWriteComplete(result->error_value());
          return;
        }
        HciWriteComplete(ZX_OK);
      });
}

// Returns false if there's an error while sending the packet to the hardware or
// if the channel peer closed its endpoint.
void BtTransportUart::HciHandleClientChannel(zx::channel* chan, zx_signals_t pending) {
  // Channel may have been closed since signal was received.
  if (!chan->is_valid()) {
    return;
  }

  // Figure out which channel we are dealing with and the constants which go
  // along with it.
  uint32_t max_buf_size;
  BtHciPacketIndicator packet_type;
  bt_hci_snoop_type_t snoop_type;
  const char* chan_name = nullptr;

  if (chan == &cmd_channel_) {
    max_buf_size = kCmdBufSize;
    packet_type = kHciCommand;
    snoop_type = BT_HCI_SNOOP_TYPE_CMD;
    chan_name = "command";
  } else if (chan == &acl_channel_) {
    max_buf_size = kAclMaxFrameSize;
    packet_type = kHciAclData;
    snoop_type = BT_HCI_SNOOP_TYPE_ACL;
    chan_name = "ACL";
  } else if (chan == &sco_channel_) {
    max_buf_size = kScoMaxFrameSize;
    packet_type = kHciSco;
    snoop_type = BT_HCI_SNOOP_TYPE_SCO;
    chan_name = "SCO";
  } else {
    // This should never happen, we only know about three packet types currently.
    ZX_ASSERT(false);
    return;
  }

  // Handle the read signal first.  If we are also peer closed, we want to make
  // sure that we have processed all of the pending messages before cleaning up.
  if (pending & ZX_CHANNEL_READABLE) {
    FDF_LOG(TRACE, "received readable signal for %s channel", chan_name);
    uint32_t length = max_buf_size - 1;
    {
      std::lock_guard guard(mutex_);

      // Do not proceed if we are not allowed to write.  Let the work thread call
      // us back again when it is safe to write.
      if (!can_write_) {
        return;
      }

      zx_status_t status;

      status =
          zx_channel_read(chan->get(), 0, write_buffer_ + 1, nullptr, length, 0, &length, nullptr);
      if (status == ZX_ERR_SHOULD_WAIT) {
        FDF_LOG(WARNING, "ignoring ZX_ERR_SHOULD_WAIT when reading %s channel", chan_name);
        return;
      }
      if (status != ZX_OK) {
        FDF_LOG(ERROR, "hci_read_thread: failed to read from %s channel %s", chan_name,
                zx_status_get_string(status));
        ChannelCleanupLocked(chan);
        return;
      }

      write_buffer_[0] = packet_type;
      length++;

      SnoopChannelWriteLocked(bt_hci_snoop_flags(snoop_type, false), write_buffer_ + 1, length - 1);
    }

    SerialWrite(write_buffer_, length);
  }

  if (pending & ZX_CHANNEL_PEER_CLOSED) {
    FDF_LOG(DEBUG, "received closed signal for %s channel", chan_name);
    std::lock_guard guard(mutex_);
    ChannelCleanupLocked(chan);
  }
}

void BtTransportUart::HciHandleUartReadEvents(const uint8_t* buf, size_t length) {
  const uint8_t* const end = buf + length;
  while (buf < end) {
    if (cur_uart_packet_type_ == kHciNone) {
      // start of new packet. read packet type
      cur_uart_packet_type_ = static_cast<BtHciPacketIndicator>(*buf++);
    }

    switch (cur_uart_packet_type_) {
      case kHciEvent:
        ProcessNextUartPacketFromReadBuffer(
            event_buffer_, sizeof(event_buffer_), &event_buffer_offset_, &buf, end,
            &BtTransportUart::EventPacketLength, &cmd_channel_, BT_HCI_SNOOP_TYPE_EVT);
        break;
      case kHciAclData:
        ProcessNextUartPacketFromReadBuffer(acl_buffer_, sizeof(acl_buffer_), &acl_buffer_offset_,
                                            &buf, end, &BtTransportUart::AclPacketLength,
                                            &acl_channel_, BT_HCI_SNOOP_TYPE_ACL);
        break;
      case kHciSco:
        ProcessNextUartPacketFromReadBuffer(sco_buffer_, sizeof(sco_buffer_), &sco_buffer_offset_,
                                            &buf, end, &BtTransportUart::ScoPacketLength,
                                            &sco_channel_, BT_HCI_SNOOP_TYPE_SCO);
        break;
      default:
        FDF_LOG(ERROR, "unsupported HCI packet type %u received. We may be out of sync",
                cur_uart_packet_type_);
        cur_uart_packet_type_ = kHciNone;
        return;
    }
  }
}

void BtTransportUart::ProcessNextUartPacketFromReadBuffer(
    uint8_t* buffer, size_t buffer_size, size_t* buffer_offset, const uint8_t** uart_src,
    const uint8_t* uart_end, PacketLengthFunction get_packet_length, zx::channel* channel,
    bt_hci_snoop_type_t snoop_type) {
  size_t packet_length = (this->*get_packet_length)();

  while (!packet_length && *uart_src < uart_end) {
    // read until we have enough to compute packet length
    buffer[*buffer_offset] = **uart_src;
    (*buffer_offset)++;
    (*uart_src)++;
    packet_length = (this->*get_packet_length)();
  }

  // Out of bytes, but we still don't know the packet length.  Just wait for
  // the next packet.
  if (!packet_length) {
    return;
  }

  if (packet_length > buffer_size) {
    FDF_LOG(ERROR,
            "packet_length is too large (%zu > %zu) during packet reassembly. Dropping and "
            "attempting to re-sync.",
            packet_length, buffer_size);

    // Reset the reassembly state machine.
    *buffer_offset = 1;
    cur_uart_packet_type_ = kHciNone;
    // Consume the rest of the UART buffer to indicate that it is corrupt.
    *uart_src = uart_end;
    return;
  }

  size_t remaining = uart_end - *uart_src;
  size_t copy_size = packet_length - *buffer_offset;
  if (copy_size > remaining) {
    copy_size = remaining;
  }

  ZX_ASSERT(*buffer_offset + copy_size <= buffer_size);
  memcpy(buffer + *buffer_offset, *uart_src, copy_size);
  *uart_src += copy_size;
  *buffer_offset += copy_size;

  if (*buffer_offset != packet_length) {
    // The packet is incomplete, the next chunk should continue the same packet.
    return;
  }

  std::lock_guard guard(mutex_);

  // Attempt to send this packet to the channel. We are working on the callback thread from the
  // UART, so we need to do this inside of the lock to make sure that nothing closes the channel
  // out from under us while we try to write. If something goes wrong here, close the channel.
  if (channel->is_valid()) {
    zx_status_t status = channel->write(/*flags=*/0, &buffer[1], packet_length - 1, nullptr, 0);
    if (status != ZX_OK) {
      FDF_LOG(ERROR, "failed to write packet: %s", zx_status_get_string(status));
      ChannelCleanupLocked(&acl_channel_);
    }
  }

  // If the snoop channel is open then try to write the packet even if |channel| was closed.
  SnoopChannelWriteLocked(bt_hci_snoop_flags(snoop_type, true), &buffer[1], packet_length - 1);

  // reset buffer
  cur_uart_packet_type_ = kHciNone;
  *buffer_offset = 1;
}

void BtTransportUart::HciReadComplete(zx_status_t status, const uint8_t* buffer, size_t length) {
  FDF_LOG(TRACE, "Read complete with status: %s", zx_status_get_string(status));

  // If we are in the process of shutting down, we are done.
  if (atomic_load_explicit(&shutting_down_, std::memory_order_relaxed)) {
    return;
  }

  if (status == ZX_OK) {
    HciHandleUartReadEvents(buffer, length);
    queue_read_task_.Post(dispatcher_);
  } else {
    // There is not much we can do in the event of a UART read error.  Do not
    // queue a read job and start the process of shutting down.
    FDF_LOG(ERROR, "Fatal UART read error (%s), shutting down", zx_status_get_string(status));
    HciBeginShutdown();
  }
}

void BtTransportUart::HciWriteComplete(zx_status_t status) {
  FDF_LOG(TRACE, "Write complete with status: %s", zx_status_get_string(status));

  // If we are in the process of shutting down, we are done as soon as we
  // have freed our operation.
  if (atomic_load_explicit(&shutting_down_, std::memory_order_relaxed)) {
    return;
  }

  if (status != ZX_OK) {
    HciBeginShutdown();
    return;
  }

  // We can write now.
  {
    std::lock_guard guard(mutex_);
    can_write_ = true;

    // Resume waiting for channel signals. If a packet was queued while the write was processing,
    // it should be immediately signaled.
    if (cmd_channel_wait_.channel->is_valid() && !cmd_channel_wait_.pending) {
      ZX_ASSERT(async_begin_wait(dispatcher_, &cmd_channel_wait_) == ZX_OK);
      cmd_channel_wait_.pending = true;
    }
    if (acl_channel_wait_.channel->is_valid() && !acl_channel_wait_.pending) {
      ZX_ASSERT(async_begin_wait(dispatcher_, &acl_channel_wait_) == ZX_OK);
      acl_channel_wait_.pending = true;
    }
    if (sco_channel_wait_.channel->is_valid() && !sco_channel_wait_.pending) {
      ZX_ASSERT(async_begin_wait(dispatcher_, &sco_channel_wait_) == ZX_OK);
      sco_channel_wait_.pending = true;
    }
  }
}

void BtTransportUart::OnChannelSignal(Wait* wait, zx_status_t status,
                                      const zx_packet_signal_t* signal) {
  {
    std::lock_guard guard(mutex_);
    wait->pending = false;
  }

  HciHandleClientChannel(wait->channel, signal->observed);

  // The readable signal wait will be re-enabled in the write completion callback.
}

zx_status_t BtTransportUart::HciOpenChannel(zx::channel* in_channel, zx_handle_t in) {
  std::lock_guard guard(mutex_);
  zx_status_t result = ZX_OK;

  if (in_channel->is_valid()) {
    FDF_LOG(ERROR, "bt-transport-uart: already bound, failing");
    result = ZX_ERR_ALREADY_BOUND;
    return result;
  }

  in_channel->reset(in);

  Wait* wait = nullptr;
  if (in_channel == &cmd_channel_) {
    FDF_LOG(DEBUG, "opening command channel");
    wait = &cmd_channel_wait_;
  } else if (in_channel == &acl_channel_) {
    FDF_LOG(DEBUG, "opening ACL channel");
    wait = &acl_channel_wait_;
  } else if (in_channel == &sco_channel_) {
    FDF_LOG(DEBUG, "opening SCO channel");
    wait = &sco_channel_wait_;
  } else if (in_channel == &snoop_channel_) {
    FDF_LOG(DEBUG, "opening snoop channel");
    // TODO(https://fxbug.dev/42172901): Handle snoop channel closed signal.
    return ZX_OK;
  }
  ZX_ASSERT(wait);
  wait->object = in_channel->get();
  wait->trigger = ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED;
  ZX_ASSERT(async_begin_wait(dispatcher_, wait) == ZX_OK);
  wait->pending = true;
  return result;
}

void BtTransportUart::OpenCommandChannel(OpenCommandChannelRequestView request,
                                         OpenCommandChannelCompleter::Sync& completer) {
  if (zx_status_t status = HciOpenChannel(&cmd_channel_, std::move(request->channel.release()));
      status != ZX_OK) {
    FDF_LOG(ERROR, "Failed to open command channel: %s", zx_status_get_string(status));
    completer.ReplyError(status);
    return;
  }
  completer.ReplySuccess();
}
void BtTransportUart::OpenAclDataChannel(OpenAclDataChannelRequestView request,
                                         OpenAclDataChannelCompleter::Sync& completer) {
  if (zx_status_t status = HciOpenChannel(&acl_channel_, std::move(request->channel.release()));
      status != ZX_OK) {
    FDF_LOG(ERROR, "Failed to open acl channel: %s", zx_status_get_string(status));
    completer.ReplyError(status);
    return;
  }
  completer.ReplySuccess();
}
void BtTransportUart::OpenSnoopChannel(OpenSnoopChannelRequestView request,
                                       OpenSnoopChannelCompleter::Sync& completer) {
  if (zx_status_t status = HciOpenChannel(&snoop_channel_, std::move(request->channel.release()));
      status != ZX_OK) {
    FDF_LOG(ERROR, "Failed to open snoop channel: %s", zx_status_get_string(status));
    completer.ReplyError(status);
    return;
  }
  completer.ReplySuccess();
}
void BtTransportUart::OpenScoDataChannel(OpenScoDataChannelRequestView request,
                                         OpenScoDataChannelCompleter::Sync& completer) {
  if (zx_status_t status = HciOpenChannel(&sco_channel_, std::move(request->channel.release()));
      status != ZX_OK) {
    FDF_LOG(ERROR, "Failed to open sco channel: %s", zx_status_get_string(status));
    completer.ReplyError(status);
    return;
  }
  completer.ReplySuccess();
}
void BtTransportUart::OpenIsoDataChannel(OpenIsoDataChannelRequestView request,
                                         OpenIsoDataChannelCompleter::Sync& completer) {
  completer.ReplyError(ZX_ERR_NOT_SUPPORTED);
}
void BtTransportUart::ConfigureSco(ConfigureScoRequestView request,
                                   ConfigureScoCompleter::Sync& completer) {
  // UART doesn't require any SCO configuration.
  completer.ReplySuccess();
}
void BtTransportUart::ResetSco(ResetScoCompleter::Sync& completer) {
  // UART doesn't require any SCO configuration, so there's nothing to do.
  completer.ReplySuccess();
}
void BtTransportUart::handle_unknown_method(
    fidl::UnknownMethodMetadata<fuchsia_hardware_bluetooth::Hci> metadata,
    fidl::UnknownMethodCompleter::Sync& completer) {
  FDF_LOG(ERROR, "Unknown method in Hci protocol, closing with ZX_ERR_NOT_SUPPORTED");
  completer.Close(ZX_ERR_NOT_SUPPORTED);
}

void BtTransportUart::GetInfo(fdf::Arena& arena, GetInfoCompleter::Sync& completer) {
  fuchsia_hardware_serial::wire::SerialPortInfo info{
      .serial_class = fuchsia_hardware_serial::wire::Class::kBluetoothHci,
      .serial_pid = serial_pid_,
  };
  completer.buffer(arena).ReplySuccess(info);
}
void BtTransportUart::Config(ConfigRequestView request, fdf::Arena& arena,
                             ConfigCompleter::Sync& completer) {
  auto result = serial_client_.sync().buffer(arena)->Config(
      request->baud_rate, fuchsia_hardware_serialimpl::wire::kSerialSetBaudRateOnly);
  if (!result.ok()) {
    FDF_LOG(ERROR, "Config request failed with FIDL error %s", result.status_string());
    completer.buffer(arena).ReplyError(result.status());
    return;
  }
  if (result->is_error()) {
    FDF_LOG(ERROR, "Config request failed with error %s",
            zx_status_get_string(result->error_value()));
    completer.buffer(arena).ReplyError(result->error_value());
    return;
  }
  completer.buffer(arena).ReplySuccess();
}

void BtTransportUart::Enable(EnableRequestView request, fdf::Arena& arena,
                             EnableCompleter::Sync& completer) {
  completer.buffer(arena).ReplyError(ZX_ERR_NOT_SUPPORTED);
}

void BtTransportUart::Read(fdf::Arena& arena, ReadCompleter::Sync& completer) {
  completer.buffer(arena).ReplyError(ZX_ERR_NOT_SUPPORTED);
}

void BtTransportUart::Write(WriteRequestView request, fdf::Arena& arena,
                            WriteCompleter::Sync& completer) {
  completer.buffer(arena).ReplyError(ZX_ERR_NOT_SUPPORTED);
}

void BtTransportUart::CancelAll(fdf::Arena& arena, CancelAllCompleter::Sync& completer) {
  completer.buffer(arena).Reply();
}

void BtTransportUart::handle_unknown_method(
    fidl::UnknownMethodMetadata<fuchsia_hardware_serialimpl::Device> metadata,
    fidl::UnknownMethodCompleter::Sync& completer) {
  FDF_LOG(
      ERROR,
      "Unknown method in fuchsia_hardware_serialimpl::Device protocol, closing with ZX_ERR_NOT_SUPPORTED");
  completer.Close(ZX_ERR_NOT_SUPPORTED);
}

void BtTransportUart::QueueUartRead() {
  fdf::Arena arena('READ');
  serial_client_.buffer(arena)->Read().ThenExactlyOnce([this](fdf::WireUnownedResult<
                                                              fuchsia_hardware_serialimpl::Device::
                                                                  Read>& result) {
    if (!result.ok()) {
      FDF_LOG(ERROR, "Read request failed with FIDL error %s", result.status_string());
      HciReadComplete(result.status(), nullptr, 0);
      return;
    }

    if (result->is_error()) {
      if (result->error_value() == ZX_ERR_CANCELED) {
        FDF_LOG(
            WARNING,
            "Read request is cancel by the bus driver, it's likely the serial driver is de-initialized.");
      } else {
        FDF_LOG(ERROR, "Read request failed with error %s",
                zx_status_get_string(result->error_value()));
      }
      HciReadComplete(result->error_value(), nullptr, 0);
      return;
    }
    HciReadComplete(ZX_OK, result->value()->data.data(), result->value()->data.count());
  });
}

zx_status_t BtTransportUart::ServeProtocols() {
  // Add HCI service to the outgoing directory.
  auto hci_protocol = [this](fidl::ServerEnd<fuchsia_hardware_bluetooth::Hci> server_end) mutable {
    fidl::BindServer(dispatcher_, std::move(server_end), this);
  };
  fuchsia_hardware_bluetooth::HciService::InstanceHandler hci_handler(
      {.hci = std::move(hci_protocol)});
  auto status =
      outgoing()->AddService<fuchsia_hardware_bluetooth::HciService>(std::move(hci_handler));
  if (status.is_error()) {
    FDF_LOG(ERROR, "Failed to add HCI service to outgoing directory: %s\n", status.status_string());
    return status.error_value();
  }

  // Add Serial service to the outgoing directory.
  auto serial_protocol =
      [this](fdf::ServerEnd<fuchsia_hardware_serialimpl::Device> server_end) mutable {
        fdf::BindServer(driver_dispatcher()->get(), std::move(server_end), this);
      };
  fuchsia_hardware_serialimpl::Service::InstanceHandler serial_handler(
      {.device = std::move(serial_protocol)});
  status = outgoing()->AddService<fuchsia_hardware_serialimpl::Service>(std::move(serial_handler));
  if (status.is_error()) {
    FDF_LOG(ERROR, "Failed to add Serial service to outgoing directory: %s\n",
            status.status_string());
    return status.error_value();
  }

  return ZX_OK;
}

}  // namespace bt_transport_uart

FUCHSIA_DRIVER_EXPORT(bt_transport_uart::BtTransportUart);