// 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 <fidl/fuchsia.hardware.serial/cpp/wire.h>
#include <lib/async/cpp/task.h>
#include <lib/async_patterns/testing/cpp/dispatcher_bound.h>
#include <lib/driver/testing/cpp/driver_lifecycle.h>
#include <lib/driver/testing/cpp/driver_runtime.h>
#include <lib/driver/testing/cpp/fixtures/gtest_fixture.h>
#include <lib/driver/testing/cpp/test_environment.h>
#include <lib/driver/testing/cpp/test_node.h>
#include <lib/fdio/directory.h>
#include <zircon/device/bt-hci.h>

#include <queue>

namespace bt_transport_uart {
namespace {

// HCI UART packet indicators
enum BtHciPacketIndicator {
  kHciNone = 0,
  kHciCommand = 1,
  kHciAclData = 2,
  kHciSco = 3,
  kHciEvent = 4,
};

class FakeSerialDevice : public fdf::WireServer<fuchsia_hardware_serialimpl::Device> {
 public:
  explicit FakeSerialDevice() = default;

  fuchsia_hardware_serialimpl::Service::InstanceHandler GetInstanceHandler() {
    return fuchsia_hardware_serialimpl::Service::InstanceHandler({
        .device = binding_group_.CreateHandler(this, fdf::Dispatcher::GetCurrent()->get(),
                                               fidl::kIgnoreBindingClosure),
    });
  }

  void QueueReadValue(std::vector<uint8_t> buffer) {
    read_rsp_queue_.emplace(std::move(buffer));
    MaybeRespondToRead();
  }

  void QueueWithoutSignaling(std::vector<uint8_t> buffer) {
    read_rsp_queue_.emplace(std::move(buffer));
  }

  const std::vector<std::vector<uint8_t>> writes() const { return writes_; }

  bool canceled() const { return canceled_; }

  bool enabled() const { return enabled_; }

  void set_writes_paused(bool paused) {
    writes_paused_ = paused;
    MaybeRespondToWrite();
  }

  // fuchsia_hardware_serialimpl::Device FIDL implementation.
  void GetInfo(fdf::Arena& arena, GetInfoCompleter::Sync& completer) override {
    fuchsia_hardware_serial::wire::SerialPortInfo info = {
        .serial_class = fuchsia_hardware_serial::Class::kBluetoothHci,
    };

    completer.buffer(arena).ReplySuccess(info);
  }
  void Config(ConfigRequestView request, fdf::Arena& arena,
              ConfigCompleter::Sync& completer) override {
    completer.buffer(arena).ReplySuccess();
  }

  void Enable(EnableRequestView request, fdf::Arena& arena,
              EnableCompleter::Sync& completer) override {
    enabled_ = request->enable;
    completer.buffer(arena).ReplySuccess();
  }

  void Read(fdf::Arena& arena, ReadCompleter::Sync& completer) override {
    // Serial only supports 1 pending read at a time.
    if (!enabled_) {
      completer.buffer(arena).ReplyError(ZX_ERR_IO_REFUSED);
      return;
    }
    read_request_.emplace(ReadRequest{std::move(arena), completer.ToAsync()});
    // The real serial async handler will call the callback immediately if there is data
    // available, do so here to simulate the recursive callstack there.
    MaybeRespondToRead();
  }

  void Write(WriteRequestView request, fdf::Arena& arena,
             WriteCompleter::Sync& completer) override {
    ASSERT_FALSE(write_request_);
    std::vector<uint8_t> buffer(request->data.data(), request->data.data() + request->data.count());
    writes_.emplace_back(std::move(buffer));
    write_request_.emplace(WriteRequest{std::move(arena), completer.ToAsync()});
    MaybeRespondToWrite();
  }

  void CancelAll(fdf::Arena& arena, CancelAllCompleter::Sync& completer) override {
    if (read_request_) {
      read_request_->completer.buffer(read_request_->arena).ReplyError(ZX_ERR_CANCELED);
      read_request_.reset();
    }
    canceled_ = true;
    completer.buffer(arena).Reply();
  }

  void handle_unknown_method(
      fidl::UnknownMethodMetadata<fuchsia_hardware_serialimpl::Device> metadata,
      fidl::UnknownMethodCompleter::Sync& completer) override {
    ZX_PANIC("Unknown method in Serial requests");
  }

 private:
  struct ReadRequest {
    fdf::Arena arena;
    ReadCompleter::Async completer;
  };
  struct WriteRequest {
    fdf::Arena arena;
    WriteCompleter::Async completer;
  };

  void MaybeRespondToRead() {
    if (read_rsp_queue_.empty() || !read_request_) {
      return;
    }
    std::vector<uint8_t> buffer = std::move(read_rsp_queue_.front());
    read_rsp_queue_.pop();
    // Callback may send new read request synchronously, so clear read_req_.
    ReadRequest request = std::move(read_request_.value());
    read_request_.reset();
    auto data_view = fidl::VectorView<uint8_t>::FromExternal(buffer);
    request.completer.buffer(request.arena).ReplySuccess(data_view);
  }

  void MaybeRespondToWrite() {
    if (writes_paused_) {
      return;
    }
    if (!write_request_) {
      return;
    }
    write_request_->completer.buffer(write_request_->arena).ReplySuccess();
    write_request_.reset();
  }

  bool enabled_ = false;
  bool canceled_ = false;
  bool writes_paused_ = false;
  std::optional<ReadRequest> read_request_;
  std::optional<WriteRequest> write_request_;
  std::queue<std::vector<uint8_t>> read_rsp_queue_;
  std::vector<std::vector<uint8_t>> writes_;

  fdf::ServerBindingGroup<fuchsia_hardware_serialimpl::Device> binding_group_;
};

class FixtureBasedTestEnvironment : fdf_testing::Environment {
 public:
  zx::result<> Serve(fdf::OutgoingDirectory& to_driver_vfs) override {
    auto result = to_driver_vfs.AddService<fuchsia_hardware_serialimpl::Service>(
        serial_device_.GetInstanceHandler());
    return result;
  }

  FakeSerialDevice serial_device_;
};

class BackgroundFixtureConfig final {
 public:
  static constexpr bool kDriverOnForeground = false;
  static constexpr bool kAutoStartDriver = true;
  static constexpr bool kAutoStopDriver = false;

  using DriverType = BtTransportUart;
  using EnvironmentType = FixtureBasedTestEnvironment;
};

class BtTransportUartTest : public fdf_testing::DriverTestFixture<BackgroundFixtureConfig> {
 public:
  BtTransportUartTest() = default;

  void SetUp() override {
    EXPECT_TRUE(RunInEnvironmentTypeContext<bool>(
        [](FixtureBasedTestEnvironment& env) { return env.serial_device_.enabled(); }));

    zx::result connect_result = Connect<fuchsia_hardware_bluetooth::HciService::Hci>();
    ASSERT_EQ(ZX_OK, connect_result.status_value());

    ASSERT_EQ(ZX_OK, connect_result.status_value());
    hci_client_.Bind(std::move(connect_result.value()));
  }

  void TearDown() override {
    // Only PrepareStop() will be called in StopDriver(), Stop() won't be called.
    zx::result prepare_stop_result = StopDriver();
    EXPECT_EQ(ZX_OK, prepare_stop_result.status_value());

    EXPECT_TRUE(RunInEnvironmentTypeContext<bool>(
        [](FixtureBasedTestEnvironment& env) { return env.serial_device_.canceled(); }));
  }

 protected:
  // The FIDL client used in the test to call into dut Hci server.
  fidl::WireSyncClient<fuchsia_hardware_bluetooth::Hci> hci_client_;
};

// Test fixture that opens all channels and has helpers for reading/writing data.
class BtTransportUartHciProtocolTest : public BtTransportUartTest {
 public:
  void SetUp() override {
    BtTransportUartTest::SetUp();

    zx::channel cmd_chan_driver_end;
    ASSERT_EQ(zx::channel::create(/*flags=*/0, &cmd_chan_, &cmd_chan_driver_end), ZX_OK);
    {
      auto result = hci_client_->OpenCommandChannel(std::move(cmd_chan_driver_end));
      ASSERT_TRUE(result.ok());
      ASSERT_FALSE(result->is_error());
    }
    // Configure wait for readable signal on command channel.
    cmd_chan_readable_wait_.set_object(cmd_chan_.get());
    zx_status_t wait_begin_status =
        cmd_chan_readable_wait_.Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher());
    ASSERT_EQ(wait_begin_status, ZX_OK) << zx_status_get_string(wait_begin_status);

    zx::channel acl_chan_driver_end;
    ASSERT_EQ(zx::channel::create(/*flags=*/0, &acl_chan_, &acl_chan_driver_end), ZX_OK);
    {
      auto result = hci_client_->OpenAclDataChannel(std::move(acl_chan_driver_end));
      ASSERT_TRUE(result.ok());
      ASSERT_FALSE(result->is_error());
    }
    // Configure wait for readable signal on ACL channel.
    acl_chan_readable_wait_.set_object(acl_chan_.get());
    wait_begin_status =
        acl_chan_readable_wait_.Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher());
    ASSERT_EQ(wait_begin_status, ZX_OK) << zx_status_get_string(wait_begin_status);

    zx::channel sco_chan_driver_end;
    ASSERT_EQ(zx::channel::create(/*flags=*/0, &sco_chan_, &sco_chan_driver_end), ZX_OK);
    {
      auto result = hci_client_->OpenScoDataChannel(std::move(sco_chan_driver_end));
      ASSERT_TRUE(result.ok());
      ASSERT_FALSE(result->is_error());
    }
    // Configure wait for readable signal on SCO channel.
    sco_chan_readable_wait_.set_object(sco_chan_.get());
    wait_begin_status =
        sco_chan_readable_wait_.Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher());
    ASSERT_EQ(wait_begin_status, ZX_OK) << zx_status_get_string(wait_begin_status);

    zx::channel snoop_chan_driver_end;
    ZX_ASSERT(zx::channel::create(/*flags=*/0, &snoop_chan_, &snoop_chan_driver_end) == ZX_OK);
    {
      auto result = hci_client_->OpenSnoopChannel(std::move(snoop_chan_driver_end));
      ASSERT_TRUE(result.ok());
      ASSERT_FALSE(result->is_error());
    }
    // Configure wait for readable signal on snoop channel.
    snoop_chan_readable_wait_.set_object(snoop_chan_.get());
    wait_begin_status =
        snoop_chan_readable_wait_.Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher());
    ASSERT_EQ(wait_begin_status, ZX_OK) << zx_status_get_string(wait_begin_status);
  }

  void TearDown() override {
    cmd_chan_readable_wait_.Cancel();
    cmd_chan_.reset();

    acl_chan_readable_wait_.Cancel();
    acl_chan_.reset();

    sco_chan_readable_wait_.Cancel();
    sco_chan_.reset();

    snoop_chan_readable_wait_.Cancel();
    snoop_chan_.reset();

    BtTransportUartTest::TearDown();
  }

  const std::vector<std::vector<uint8_t>>& hci_events() const { return cmd_chan_received_packets_; }

  const std::vector<std::vector<uint8_t>>& snoop_packets() const {
    return snoop_chan_received_packets_;
  }

  const std::vector<std::vector<uint8_t>>& received_acl_packets() const {
    return acl_chan_received_packets_;
  }

  const std::vector<std::vector<uint8_t>>& received_sco_packets() const {
    return sco_chan_received_packets_;
  }

  zx::channel* cmd_chan() { return &cmd_chan_; }

  zx::channel* acl_chan() { return &acl_chan_; }

  zx::channel* sco_chan() { return &sco_chan_; }

 private:
  // This method is shared by the waits for all channels. |wait| is used to differentiate which
  // wait called the method.
  void OnChannelReady(async_dispatcher_t*, async::WaitBase* wait, zx_status_t status,
                      const zx_packet_signal_t* signal) {
    ASSERT_EQ(status, ZX_OK);
    ASSERT_TRUE(signal->observed & ZX_CHANNEL_READABLE);

    zx::unowned_channel chan;
    std::vector<std::vector<uint8_t>>* received_packets = nullptr;
    if (wait == &cmd_chan_readable_wait_) {
      chan = zx::unowned_channel(cmd_chan_);
      received_packets = &cmd_chan_received_packets_;
    } else if (wait == &snoop_chan_readable_wait_) {
      chan = zx::unowned_channel(snoop_chan_);
      received_packets = &snoop_chan_received_packets_;
    } else if (wait == &acl_chan_readable_wait_) {
      chan = zx::unowned_channel(acl_chan_);
      received_packets = &acl_chan_received_packets_;
    } else if (wait == &sco_chan_readable_wait_) {
      chan = zx::unowned_channel(sco_chan_);
      received_packets = &sco_chan_received_packets_;
    } else {
      ADD_FAILURE() << "unexpected channel in OnChannelReady";
      return;
    }

    // Make byte buffer arbitrarily large enough to hold test packets.
    std::vector<uint8_t> bytes(255);
    uint32_t actual_bytes;
    zx_status_t read_status = chan->read(
        /*flags=*/0, bytes.data(), /*handles=*/nullptr, static_cast<uint32_t>(bytes.size()),
        /*num_handles=*/0, &actual_bytes, /*actual_handles=*/nullptr);
    ASSERT_EQ(read_status, ZX_OK);
    bytes.resize(actual_bytes);
    received_packets->push_back(std::move(bytes));

    // The wait needs to be restarted.
    zx_status_t wait_begin_status = wait->Begin(fdf::Dispatcher::GetCurrent()->async_dispatcher());
    ASSERT_EQ(wait_begin_status, ZX_OK) << zx_status_get_string(wait_begin_status);
  }

  zx::channel cmd_chan_;
  zx::channel acl_chan_;
  zx::channel sco_chan_;
  zx::channel snoop_chan_;

  async::WaitMethod<BtTransportUartHciProtocolTest, &BtTransportUartHciProtocolTest::OnChannelReady>
      cmd_chan_readable_wait_{this, zx_handle_t(), ZX_CHANNEL_READABLE};
  async::WaitMethod<BtTransportUartHciProtocolTest, &BtTransportUartHciProtocolTest::OnChannelReady>
      snoop_chan_readable_wait_{this, zx_handle_t(), ZX_CHANNEL_READABLE};
  async::WaitMethod<BtTransportUartHciProtocolTest, &BtTransportUartHciProtocolTest::OnChannelReady>
      acl_chan_readable_wait_{this, zx_handle_t(), ZX_CHANNEL_READABLE};
  async::WaitMethod<BtTransportUartHciProtocolTest, &BtTransportUartHciProtocolTest::OnChannelReady>
      sco_chan_readable_wait_{this, zx_handle_t(), ZX_CHANNEL_READABLE};

  std::vector<std::vector<uint8_t>> cmd_chan_received_packets_;
  std::vector<std::vector<uint8_t>> snoop_chan_received_packets_;
  std::vector<std::vector<uint8_t>> acl_chan_received_packets_;
  std::vector<std::vector<uint8_t>> sco_chan_received_packets_;
};

TEST_F(BtTransportUartHciProtocolTest, SendAclPackets) {
  const uint8_t kNumPackets = 25;
  for (uint8_t i = 0; i < kNumPackets; i++) {
    const std::vector<uint8_t> kAclPacket = {i};
    zx_status_t write_status =
        acl_chan()->write(/*flags=*/0, kAclPacket.data(), static_cast<uint32_t>(kAclPacket.size()),
                          /*handles=*/nullptr,
                          /*num_handles=*/0);
    ASSERT_EQ(write_status, ZX_OK);
  }
  // Allow ACL packets to be processed and sent to the serial device.
  // This function waits until the condition in the lambda is satisfied, The default poll interval
  // is 10 msec, the default wait timeout is 1 sec. The function returns true if it didn't timeout.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == kNumPackets;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  ASSERT_EQ(packets.size(), kNumPackets);
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // A packet indicator should be prepended.
    std::vector<uint8_t> expected = {BtHciPacketIndicator::kHciAclData, i};
    EXPECT_EQ(packets[i], expected);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumPackets; });
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // Snoop packets should have a snoop packet flag prepended (NOT a UART packet indicator).
    const std::vector<uint8_t> kExpectedSnoopPacket = {BT_HCI_SNOOP_TYPE_ACL,  // Snoop packet flag
                                                       i};
    EXPECT_EQ(snoop_packets()[i], kExpectedSnoopPacket);
  }
}

TEST_F(BtTransportUartHciProtocolTest, AclReadableSignalIgnoredUntilFirstWriteCompletes) {
  // Delay completion of first write.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(true); });

  const uint8_t kNumPackets = 2;
  for (uint8_t i = 0; i < kNumPackets; i++) {
    const std::vector<uint8_t> kAclPacket = {i};
    zx_status_t write_status =
        acl_chan()->write(/*flags=*/0, kAclPacket.data(), static_cast<uint32_t>(kAclPacket.size()),
                          /*handles=*/nullptr,
                          /*num_handles=*/0);
    ASSERT_EQ(write_status, ZX_OK);
  }

  // Wait until the first packet has been received by fake serial device.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 1u;
  });

  // Call the first packet's completion callback. This should resume waiting for signals.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(false); });

  // Wait for the readable signal to be processed, and both packets has been received by fake
  // serial device.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == kNumPackets;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  ASSERT_EQ(packets.size(), kNumPackets);
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // A packet indicator should be prepended.
    std::vector<uint8_t> expected = {BtHciPacketIndicator::kHciAclData, i};
    EXPECT_EQ(packets[i], expected);
  }
}

TEST_F(BtTransportUartHciProtocolTest, ReceiveAclPacketsIn2Parts) {
  const std::vector<uint8_t> kSnoopAclBuffer = {
      BT_HCI_SNOOP_TYPE_ACL | BT_HCI_SNOOP_FLAG_RECV,  // Snoop packet flag
      0x00,
      0x00,  // arbitrary header fields
      0x02,
      0x00,  // 2-byte length in little endian
      0x01,
      0x02,  // arbitrary payload
  };
  std::vector<uint8_t> kSerialAclBuffer = kSnoopAclBuffer;
  kSerialAclBuffer[0] = BtHciPacketIndicator::kHciAclData;
  const std::vector<uint8_t> kAclBuffer(kSnoopAclBuffer.begin() + 1, kSnoopAclBuffer.end());
  // Split the packet length field in half to test corner case.
  const std::vector<uint8_t> kPart1(kSerialAclBuffer.begin(), kSerialAclBuffer.begin() + 4);
  const std::vector<uint8_t> kPart2(kSerialAclBuffer.begin() + 4, kSerialAclBuffer.end());

  const size_t kNumPackets = 20;
  for (size_t i = 0; i < kNumPackets; i++) {
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart1);
    });
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart2);
    });
  }

  runtime().RunUntil(
      [&]() { return received_acl_packets().size() == static_cast<size_t>(kNumPackets); });

  for (const std::vector<uint8_t>& packet : received_acl_packets()) {
    EXPECT_EQ(packet.size(), kAclBuffer.size());
    EXPECT_EQ(packet, kAclBuffer);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumPackets; });
  for (const std::vector<uint8_t>& packet : snoop_packets()) {
    EXPECT_EQ(packet, kSnoopAclBuffer);
  }
}

TEST_F(BtTransportUartHciProtocolTest, ReceiveAclPacketsLotsInQueue) {
  const std::vector<uint8_t> kSnoopAclBuffer = {
      BT_HCI_SNOOP_TYPE_ACL | BT_HCI_SNOOP_FLAG_RECV,  // Snoop packet flag
      0x00,
      0x00,  // arbitrary header fields
      0x02,
      0x00,  // 2-byte length in little endian
      0x01,
      0x02,  // arbitrary payload
  };
  std::vector<uint8_t> kSerialAclBuffer = kSnoopAclBuffer;
  kSerialAclBuffer[0] = BtHciPacketIndicator::kHciAclData;
  const std::vector<uint8_t> kAclBuffer(kSnoopAclBuffer.begin() + 1, kSnoopAclBuffer.end());
  // Split the packet length field in half to test corner case.
  const std::vector<uint8_t> kPart1(kSerialAclBuffer.begin(), kSerialAclBuffer.begin() + 4);
  const std::vector<uint8_t> kPart2(kSerialAclBuffer.begin() + 4, kSerialAclBuffer.end());

  const size_t kNumPackets = 1000;
  for (size_t i = 0; i < kNumPackets; i++) {
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueWithoutSignaling(kPart1);
    });
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueWithoutSignaling(kPart2);
    });
  }
  RunInEnvironmentTypeContext(
      [&](FixtureBasedTestEnvironment& env) { return env.serial_device_.QueueReadValue(kPart1); });
  RunInEnvironmentTypeContext(
      [&](FixtureBasedTestEnvironment& env) { return env.serial_device_.QueueReadValue(kPart2); });

  // Wait Until all the packets to be received.
  runtime().RunUntil(
      [&]() { return received_acl_packets().size() == static_cast<size_t>(kNumPackets + 1); });

  ASSERT_EQ(received_acl_packets().size(), static_cast<size_t>(kNumPackets + 1));
  for (const std::vector<uint8_t>& packet : received_acl_packets()) {
    EXPECT_EQ(packet.size(), kAclBuffer.size());
    EXPECT_EQ(packet, kAclBuffer);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumPackets + 1; });
  for (const std::vector<uint8_t>& packet : snoop_packets()) {
    EXPECT_EQ(packet, kSnoopAclBuffer);
  }
}

TEST_F(BtTransportUartHciProtocolTest, SendHciCommands) {
  const std::vector<uint8_t> kSnoopCmd0 = {
      BT_HCI_SNOOP_TYPE_CMD,  // Snoop packet flag
      0x00,                   // arbitrary payload
  };
  const std::vector<uint8_t> kCmd0(kSnoopCmd0.begin() + 1, kSnoopCmd0.end());
  const std::vector<uint8_t> kUartCmd0 = {
      BtHciPacketIndicator::kHciCommand,  // UART packet indicator
      0x00,                               // arbitrary payload
  };
  zx_status_t write_status =
      cmd_chan()->write(/*flags=*/0, kCmd0.data(), static_cast<uint32_t>(kCmd0.size()),
                        /*handles=*/nullptr,
                        /*num_handles=*/0);
  EXPECT_EQ(write_status, ZX_OK);

  // Wait until the first packet is received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 1u;
  });

  const std::vector<uint8_t> kSnoopCmd1 = {
      BT_HCI_SNOOP_TYPE_CMD,  // Snoop packet flag
      0x01,                   // arbitrary payload
  };
  const std::vector<uint8_t> kCmd1(kSnoopCmd1.begin() + 1, kSnoopCmd1.end());
  const std::vector<uint8_t> kUartCmd1 = {
      BtHciPacketIndicator::kHciCommand,  // UART packet indicator
      0x01,                               // arbitrary payload
  };
  write_status = cmd_chan()->write(/*flags=*/0, kCmd1.data(), static_cast<uint32_t>(kCmd1.size()),
                                   /*handles=*/nullptr,
                                   /*num_handles=*/0);
  EXPECT_EQ(write_status, ZX_OK);

  // Wait until the second packet is received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 2u;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  EXPECT_EQ(packets[0], kUartCmd0);
  EXPECT_EQ(packets[1], kUartCmd1);

  runtime().RunUntil([&]() { return snoop_packets().size() == 2u; });
  EXPECT_EQ(snoop_packets()[0], kSnoopCmd0);
  EXPECT_EQ(snoop_packets()[1], kSnoopCmd1);
}

TEST_F(BtTransportUartHciProtocolTest, CommandReadableSignalIgnoredUntilFirstWriteCompletes) {
  // Delay completion of first write.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(true); });

  const std::vector<uint8_t> kUartCmd0 = {
      BtHciPacketIndicator::kHciCommand,  // UART packet indicator
      0x00,                               // arbitrary payload
  };
  const std::vector<uint8_t> kCmd0(kUartCmd0.begin() + 1, kUartCmd0.end());
  zx_status_t write_status =
      cmd_chan()->write(/*flags=*/0, kCmd0.data(), static_cast<uint32_t>(kCmd0.size()),
                        /*handles=*/nullptr,
                        /*num_handles=*/0);
  EXPECT_EQ(write_status, ZX_OK);

  const std::vector<uint8_t> kUartCmd1 = {
      BtHciPacketIndicator::kHciCommand,  // UART packet indicator
      0x01,                               // arbitrary payload
  };
  const std::vector<uint8_t> kCmd1(kUartCmd1.begin() + 1, kUartCmd1.end());
  write_status = cmd_chan()->write(/*flags=*/0, kCmd1.data(), static_cast<uint32_t>(kCmd1.size()),
                                   /*handles=*/nullptr,
                                   /*num_handles=*/0);
  EXPECT_EQ(write_status, ZX_OK);

  // Wait until the first packet is received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 1u;
  });

  // Make sure the number of packet received never run over 1 before the pause is released.
  EXPECT_FALSE(runtime().RunWithTimeoutOrUntil(
      [&]() {
        return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
                 return env.serial_device_.writes().size();
               }) > 1u;
      },
      zx::msec(500)));

  // Call the first command's completion callback. This should resume waiting for signals.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(false); });

  // Wait for the readable signal to be processed and the second packet is received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 2u;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  EXPECT_EQ(packets[0], kUartCmd0);
  EXPECT_EQ(packets[1], kUartCmd1);
}

TEST_F(BtTransportUartHciProtocolTest, ReceiveManyHciEventsSplitIntoTwoResponses) {
  const std::vector<uint8_t> kSnoopEventBuffer = {
      BT_HCI_SNOOP_TYPE_EVT | BT_HCI_SNOOP_FLAG_RECV,  // Snoop packet flag
      0x01,                                            // event code
      0x02,                                            // parameter_total_size
      0x03,                                            // arbitrary parameter
      0x04                                             // arbitrary parameter
  };
  const std::vector<uint8_t> kEventBuffer(kSnoopEventBuffer.begin() + 1, kSnoopEventBuffer.end());
  std::vector<uint8_t> kSerialEventBuffer = kSnoopEventBuffer;
  kSerialEventBuffer[0] = BtHciPacketIndicator::kHciEvent;
  const std::vector<uint8_t> kPart1(kSerialEventBuffer.begin(), kSerialEventBuffer.begin() + 3);
  const std::vector<uint8_t> kPart2(kSerialEventBuffer.begin() + 3, kSerialEventBuffer.end());

  const size_t kNumEvents = 20;
  for (size_t i = 0; i < kNumEvents; i++) {
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart1);
    });
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart2);
    });
  }

  // Wait for all the packets to be received.
  runtime().RunUntil([&]() { return hci_events().size() == kNumEvents; });

  ASSERT_EQ(hci_events().size(), kNumEvents);
  for (const std::vector<uint8_t>& event : hci_events()) {
    EXPECT_EQ(event, kEventBuffer);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumEvents; });
  for (const std::vector<uint8_t>& packet : snoop_packets()) {
    EXPECT_EQ(packet, kSnoopEventBuffer);
  }
}

TEST_F(BtTransportUartHciProtocolTest, SendScoPackets) {
  const size_t kNumPackets = 25;
  for (size_t i = 0; i < kNumPackets; i++) {
    const std::vector<uint8_t> kScoPacket = {static_cast<uint8_t>(i)};
    zx_status_t write_status =
        sco_chan()->write(/*flags=*/0, kScoPacket.data(), static_cast<uint32_t>(kScoPacket.size()),
                          /*handles=*/nullptr,
                          /*num_handles=*/0);
    ASSERT_EQ(write_status, ZX_OK);
  }
  // Allow SCO packets to be processed and sent to the serial device.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == kNumPackets;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // A packet indicator should be prepended.
    std::vector<uint8_t> expected = {BtHciPacketIndicator::kHciSco, i};
    EXPECT_EQ(packets[i], expected);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumPackets; });
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // Snoop packets should have a snoop packet flag prepended (NOT a UART packet indicator).
    const std::vector<uint8_t> kExpectedSnoopPacket = {BT_HCI_SNOOP_TYPE_SCO, i};
    EXPECT_EQ(snoop_packets()[i], kExpectedSnoopPacket);
  }
}

TEST_F(BtTransportUartHciProtocolTest, ScoReadableSignalIgnoredUntilFirstWriteCompletes) {
  // Delay completion of first write.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(true); });

  const uint8_t kNumPackets = 2;
  for (uint8_t i = 0; i < kNumPackets; i++) {
    const std::vector<uint8_t> kScoPacket = {i};
    zx_status_t write_status =
        sco_chan()->write(/*flags=*/0, kScoPacket.data(), static_cast<uint32_t>(kScoPacket.size()),
                          /*handles=*/nullptr,
                          /*num_handles=*/0);
    ASSERT_EQ(write_status, ZX_OK);
  }

  // Wait for the first packet to be received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == 1u;
  });

  // Call the first packet's completion callback. This should resume waiting for signals.
  RunInEnvironmentTypeContext(
      [](FixtureBasedTestEnvironment& env) { return env.serial_device_.set_writes_paused(false); });

  // Wait for the readable signal to be processed and the second packet to be received.
  runtime().RunUntil([&]() {
    return RunInEnvironmentTypeContext<size_t>([](FixtureBasedTestEnvironment& env) {
             return env.serial_device_.writes().size();
           }) == kNumPackets;
  });

  const std::vector<std::vector<uint8_t>> packets =
      RunInEnvironmentTypeContext<const std::vector<std::vector<uint8_t>>>(
          [](FixtureBasedTestEnvironment& env) { return env.serial_device_.writes(); });
  ASSERT_EQ(packets.size(), kNumPackets);
  for (uint8_t i = 0; i < kNumPackets; i++) {
    // A packet indicator should be prepended.
    std::vector<uint8_t> expected = {BtHciPacketIndicator::kHciSco, i};
    EXPECT_EQ(packets[i], expected);
  }
}

TEST_F(BtTransportUartHciProtocolTest, ReceiveScoPacketsIn2Parts) {
  const std::vector<uint8_t> kSnoopScoBuffer = {
      BT_HCI_SNOOP_TYPE_SCO | BT_HCI_SNOOP_FLAG_RECV,  // Snoop packet flag
      0x07,
      0x08,  // arbitrary header fields
      0x01,  // 1-byte payload length in little endian
      0x02,  // arbitrary payload
  };
  std::vector<uint8_t> kSerialScoBuffer = kSnoopScoBuffer;
  kSerialScoBuffer[0] = BtHciPacketIndicator::kHciSco;
  const std::vector<uint8_t> kScoBuffer(kSnoopScoBuffer.begin() + 1, kSnoopScoBuffer.end());
  // Split the packet before length field to test corner case.
  const std::vector<uint8_t> kPart1(kSerialScoBuffer.begin(), kSerialScoBuffer.begin() + 3);
  const std::vector<uint8_t> kPart2(kSerialScoBuffer.begin() + 3, kSerialScoBuffer.end());

  const size_t kNumPackets = 20;
  for (size_t i = 0; i < kNumPackets; i++) {
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart1);
    });
    RunInEnvironmentTypeContext([&](FixtureBasedTestEnvironment& env) {
      return env.serial_device_.QueueReadValue(kPart2);
    });
  }

  // Wait for all the packets to be received.
  runtime().RunUntil(
      [&]() { return received_sco_packets().size() == static_cast<size_t>(kNumPackets); });

  for (const std::vector<uint8_t>& packet : received_sco_packets()) {
    EXPECT_EQ(packet.size(), kScoBuffer.size());
    EXPECT_EQ(packet, kScoBuffer);
  }

  runtime().RunUntil([&]() { return snoop_packets().size() == kNumPackets; });
  for (const std::vector<uint8_t>& packet : snoop_packets()) {
    EXPECT_EQ(packet, kSnoopScoBuffer);
  }
}

}  // namespace
}  // namespace bt_transport_uart