// 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 "src/connectivity/bluetooth/core/bt-host/transport/sco_data_channel.h"

#include <lib/gtest/test_loop_fixture.h>

#include <gtest/gtest.h>

#include "src/connectivity/bluetooth/core/bt-host/common/test_helpers.h"
#include "src/connectivity/bluetooth/core/bt-host/testing/controller_test.h"
#include "src/connectivity/bluetooth/core/bt-host/testing/mock_controller.h"
#include "src/connectivity/bluetooth/core/bt-host/testing/test_packets.h"

namespace bt::hci {
namespace {

constexpr hci_spec::ConnectionHandle kConnectionHandle0 = 0x0000;
constexpr hci_spec::ConnectionHandle kConnectionHandle1 = 0x0001;
constexpr size_t kBufferMaxNumPackets = 2;

constexpr hci_spec::SynchronousConnectionParameters kMsbcConnectionParameters{
    .transmit_bandwidth = 0,
    .receive_bandwidth = 0,
    .transmit_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kMSbc,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .receive_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kMSbc,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .transmit_codec_frame_size_bytes = 0,
    .receive_codec_frame_size_bytes = 0,
    .input_bandwidth = 32000,
    .output_bandwidth = 32000,
    .input_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kMSbc,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .output_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kMSbc,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .input_coded_data_size_bits = 16,
    .output_coded_data_size_bits = 16,
    .input_pcm_data_format = hci_spec::PcmDataFormat::kUnsigned,
    .output_pcm_data_format = hci_spec::PcmDataFormat::kUnsigned,
    .input_pcm_sample_payload_msb_position = 0,
    .output_pcm_sample_payload_msb_position = 0,
    .input_data_path = hci_spec::ScoDataPath::kHci,
    .output_data_path = hci_spec::ScoDataPath::kHci,
    .input_transport_unit_size_bits = 0,
    .output_transport_unit_size_bits = 0,
    .max_latency_ms = 0,
    .packet_types = 0,
    .retransmission_effort = hci_spec::ScoRetransmissionEffort::kNone,
};

constexpr hci_spec::SynchronousConnectionParameters kCvsdConnectionParameters{
    .transmit_bandwidth = 0,
    .receive_bandwidth = 0,
    .transmit_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kCvsd,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .receive_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kCvsd,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .transmit_codec_frame_size_bytes = 0,
    .receive_codec_frame_size_bytes = 0,
    .input_bandwidth = 8000,
    .output_bandwidth = 8000,
    .input_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kCvsd,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .output_coding_format =
        hci_spec::VendorCodingFormat{
            .coding_format = hci_spec::CodingFormat::kCvsd,
            .company_id = 0,
            .vendor_codec_id = 0,
        },
    .input_coded_data_size_bits = 8,
    .output_coded_data_size_bits = 8,
    .input_pcm_data_format = hci_spec::PcmDataFormat::kUnsigned,
    .output_pcm_data_format = hci_spec::PcmDataFormat::kUnsigned,
    .input_pcm_sample_payload_msb_position = 0,
    .output_pcm_sample_payload_msb_position = 0,
    .input_data_path = hci_spec::ScoDataPath::kHci,
    .output_data_path = hci_spec::ScoDataPath::kHci,
    .input_transport_unit_size_bits = 0,
    .output_transport_unit_size_bits = 0,
    .max_latency_ms = 0,
    .packet_types = 0,
    .retransmission_effort = hci_spec::ScoRetransmissionEffort::kNone,
};

class FakeScoConnection : public ScoDataChannel::ConnectionInterface {
 public:
  explicit FakeScoConnection(
      ScoDataChannel* data_channel, hci_spec::ConnectionHandle handle = kConnectionHandle0,
      hci_spec::SynchronousConnectionParameters params = kMsbcConnectionParameters)
      : handle_(handle), params_(params), data_channel_(data_channel), weak_ptr_factory_(this) {}

  ~FakeScoConnection() override = default;

  void QueuePacket(std::unique_ptr<ScoDataPacket> packet) {
    queued_packets_.push(std::move(packet));
    data_channel_->OnOutboundPacketReadable();
  }

  const std::vector<std::unique_ptr<ScoDataPacket>>& received_packets() const {
    return received_packets_;
  }
  const std::queue<std::unique_ptr<ScoDataPacket>>& queued_packets() const {
    return queued_packets_;
  }

  uint16_t hci_error_count() const { return hci_error_count_; }

  fxl::WeakPtr<FakeScoConnection> GetWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }

  // ScoDataChannel::ConnectionInterface overrides:

  hci_spec::ConnectionHandle handle() const override { return handle_; }

  hci_spec::SynchronousConnectionParameters parameters() override { return params_; }

  std::unique_ptr<ScoDataPacket> GetNextOutboundPacket() override {
    if (queued_packets_.empty()) {
      return nullptr;
    }
    std::unique_ptr<ScoDataPacket> packet = std::move(queued_packets_.front());
    queued_packets_.pop();
    return packet;
  }

  void ReceiveInboundPacket(std::unique_ptr<ScoDataPacket> packet) override {
    received_packets_.push_back(std::move(packet));
  }

  void OnHciError() override { hci_error_count_++; }

 private:
  hci_spec::ConnectionHandle handle_;
  hci_spec::SynchronousConnectionParameters params_;
  std::queue<std::unique_ptr<ScoDataPacket>> queued_packets_;
  std::vector<std::unique_ptr<ScoDataPacket>> received_packets_;
  ScoDataChannel* data_channel_;
  uint16_t hci_error_count_ = 0;
  fxl::WeakPtrFactory<FakeScoConnection> weak_ptr_factory_;
};

using TestingBase = bt::testing::ControllerTest<bt::testing::MockController>;
class ScoDataChannelTest : public TestingBase {
 public:
  void SetUp() override {
    TestingBase::SetUp();
    StartTestDevice();

    DataBufferInfo buffer_info(/*max_data_length=*/10, kBufferMaxNumPackets);
    InitializeScoDataChannel(buffer_info);
  }
};

class ScoDataChannelSingleConnectionTest : public ScoDataChannelTest {
 public:
  void SetUp() override {
    ScoDataChannelTest::SetUp();

    set_configure_sco_cb([this](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                                HciWrapper::StatusCallback callback) {
      config_count_++;
      EXPECT_EQ(format, ScoCodingFormat::kMsbc);
      EXPECT_EQ(encoding, ScoEncoding::k16Bits);
      EXPECT_EQ(rate, ScoSampleRate::k16Khz);
      callback(ZX_OK);
    });

    set_reset_sco_cb([this](HciWrapper::StatusCallback callback) {
      reset_count_++;
      callback(ZX_OK);
    });

    connection_.emplace(sco_data_channel());

    sco_data_channel()->RegisterConnection(connection_->GetWeakPtr());
    EXPECT_EQ(config_count_, 1);
    EXPECT_EQ(reset_count_, 0);
  }

  void TearDown() override {
    sco_data_channel()->UnregisterConnection(connection_->handle());
    EXPECT_EQ(config_count_, 1);
    EXPECT_EQ(reset_count_, 1);
    set_configure_sco_cb(nullptr);
    set_reset_sco_cb(nullptr);
    ScoDataChannelTest::TearDown();
  }

  FakeScoConnection* connection() { return &connection_.value(); }

 private:
  std::optional<FakeScoConnection> connection_;
  int config_count_ = 0;
  int reset_count_ = 0;
};

TEST_F(ScoDataChannelSingleConnectionTest, SendManyMsbcPackets) {
  // Queue 1 more than than the max number of packets (1 packet will remain queued).
  for (size_t i = 0; i <= kBufferMaxNumPackets; i++) {
    std::unique_ptr<ScoDataPacket> packet =
        ScoDataPacket::New(kConnectionHandle0, /*payload_size=*/1);
    packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i);

    // The last packet should remain queued.
    if (i < kBufferMaxNumPackets) {
      EXPECT_SCO_PACKET_OUT(test_device(), StaticByteBuffer(LowerBits(kConnectionHandle0),
                                                            UpperBits(kConnectionHandle0),
                                                            0x01,  // payload length
                                                            static_cast<uint8_t>(i)));
    }
    connection()->QueuePacket(std::move(packet));
    RunLoopUntilIdle();
  }

  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  EXPECT_SCO_PACKET_OUT(
      test_device(), StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                      0x01,  // payload length
                                      static_cast<uint8_t>(kBufferMaxNumPackets)));
  test_device()->SendCommandChannelPacket(
      bt::testing::NumberOfCompletedPacketsPacket(kConnectionHandle0, 1));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());
}

TEST_F(ScoDataChannelSingleConnectionTest, ReceiveManyPackets) {
  for (uint8_t i = 0; i < 20; i++) {
    SCOPED_TRACE(i);
    StaticByteBuffer packet(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                            0x01,  // payload length
                            i      // payload
    );
    test_device()->SendScoDataChannelPacket(packet);
    RunLoopUntilIdle();
    ASSERT_EQ(connection()->received_packets().size(), static_cast<size_t>(i) + 1);
    EXPECT_TRUE(ContainersEqual(connection()->received_packets()[i]->view().data(), packet));
  }
}

TEST_F(ScoDataChannelTest, RegisterTwoConnectionsAndUnregisterFirstConnection) {
  int config_count = 0;
  set_configure_sco_cb([&](auto, auto, auto, HciWrapper::StatusCallback callback) {
    config_count++;
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  FakeScoConnection connection_0(sco_data_channel());
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);

  FakeScoConnection connection_1(sco_data_channel(), kConnectionHandle1);
  sco_data_channel()->RegisterConnection(connection_1.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);

  StaticByteBuffer packet_0(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                            0x01,  // payload length
                            0x00   // payload
  );
  test_device()->SendScoDataChannelPacket(packet_0);
  RunLoopUntilIdle();
  ASSERT_EQ(connection_0.received_packets().size(), 1u);
  ASSERT_EQ(connection_1.received_packets().size(), 0u);

  StaticByteBuffer packet_1(LowerBits(kConnectionHandle1), UpperBits(kConnectionHandle1),
                            0x01,  // payload length
                            0x01   // payload
  );
  test_device()->SendScoDataChannelPacket(packet_1);
  RunLoopUntilIdle();
  ASSERT_EQ(connection_0.received_packets().size(), 1u);
  // The packet should be received even though connection_1 isn't the active connection.
  ASSERT_EQ(connection_1.received_packets().size(), 1u);

  EXPECT_SCO_PACKET_OUT(test_device(), packet_0);
  std::unique_ptr<ScoDataPacket> out_packet_0 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_0->mutable_view()->mutable_data().Write(packet_0);
  out_packet_0->InitializeFromBuffer();
  connection_0.QueuePacket(std::move(out_packet_0));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());
  test_device()->SendCommandChannelPacket(
      bt::testing::NumberOfCompletedPacketsPacket(kConnectionHandle0, 1));

  std::unique_ptr<ScoDataPacket> out_packet_1 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_1->mutable_view()->mutable_data().Write(packet_1);
  out_packet_1->InitializeFromBuffer();
  // The packet should be sent even though connection_1 isn't the active connection.
  EXPECT_SCO_PACKET_OUT(test_device(), packet_1);
  connection_1.QueuePacket(std::move(out_packet_1));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());
  // This is necessary because kBufferMaxNumPackets is 2, so we won't be able to send
  // any more packets until at least 1 is ACKed by the controller.
  test_device()->SendCommandChannelPacket(
      bt::testing::NumberOfCompletedPacketsPacket(kConnectionHandle1, 1));

  // connection_1 should become the active connection (+1 to config_count).
  sco_data_channel()->UnregisterConnection(connection_0.handle());
  EXPECT_EQ(config_count, 2);
  EXPECT_EQ(reset_count, 0);
  RunLoopUntilIdle();

  out_packet_1 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_1->mutable_view()->mutable_data().Write(packet_1);
  out_packet_1->InitializeFromBuffer();
  // Now that connection_1 is the active connection, packets should still be sent.
  EXPECT_SCO_PACKET_OUT(test_device(), packet_1);
  connection_1.QueuePacket(std::move(out_packet_1));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  // There are no active connections now (+1 to reset_count).
  sco_data_channel()->UnregisterConnection(connection_1.handle());
  EXPECT_EQ(config_count, 2);
  EXPECT_EQ(reset_count, 1);
}

TEST_F(ScoDataChannelTest, RegisterTwoConnectionsAndClearControllerPacketCountOfFirstConnection) {
  set_configure_sco_cb(
      [](auto, auto, auto, HciWrapper::StatusCallback callback) { callback(ZX_OK); });

  set_reset_sco_cb([](HciWrapper::StatusCallback callback) { callback(ZX_OK); });

  FakeScoConnection connection_0(sco_data_channel());
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());

  FakeScoConnection connection_1(sco_data_channel(), kConnectionHandle1);
  sco_data_channel()->RegisterConnection(connection_1.GetWeakPtr());

  auto packet_0 = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                   0x01,  // payload length
                                   0x00   // payload
  );
  auto packet_1 = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                   0x01,  // payload length
                                   0x01   // payload
  );
  auto packet_2 = StaticByteBuffer(LowerBits(kConnectionHandle1), UpperBits(kConnectionHandle1),
                                   0x01,  // payload length
                                   0x02   // payload
  );

  EXPECT_SCO_PACKET_OUT(test_device(), packet_0);
  std::unique_ptr<ScoDataPacket> out_packet_0 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_0->mutable_view()->mutable_data().Write(packet_0);
  out_packet_0->InitializeFromBuffer();
  connection_0.QueuePacket(std::move(out_packet_0));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  // The second packet should fill up the controller buffer (kBufferMaxNumPackets).
  ASSERT_EQ(kBufferMaxNumPackets, 2u);
  EXPECT_SCO_PACKET_OUT(test_device(), packet_1);
  std::unique_ptr<ScoDataPacket> out_packet_1 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_1->mutable_view()->mutable_data().Write(packet_1);
  out_packet_1->InitializeFromBuffer();
  connection_0.QueuePacket(std::move(out_packet_1));
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  std::unique_ptr<ScoDataPacket> out_packet_2 = ScoDataPacket::New(/*payload_size=*/1);
  out_packet_2->mutable_view()->mutable_data().Write(packet_2);
  out_packet_2->InitializeFromBuffer();
  // The packet should NOT be sent because the controller buffer is full.
  connection_1.QueuePacket(std::move(out_packet_2));
  RunLoopUntilIdle();

  // connection_1 should become the active connection, but out_packet_2 can't be sent yet.
  sco_data_channel()->UnregisterConnection(connection_0.handle());
  RunLoopUntilIdle();
  EXPECT_EQ(connection_1.queued_packets().size(), 1u);

  // Clearing the pending packet count for connection_0 should result in packet_2 being sent.
  EXPECT_SCO_PACKET_OUT(test_device(), packet_2);
  sco_data_channel()->ClearControllerPacketCount(connection_0.handle());
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  // There are no active connections now.
  sco_data_channel()->UnregisterConnection(connection_1.handle());
  sco_data_channel()->ClearControllerPacketCount(connection_1.handle());
  RunLoopUntilIdle();
}

TEST_F(ScoDataChannelSingleConnectionTest, IgnoreInboundPacketForUnknownConnectionHandle) {
  // kConnectionHandle1 is not registered.
  auto packet = StaticByteBuffer(LowerBits(kConnectionHandle1), UpperBits(kConnectionHandle1),
                                 0x01,  // payload length
                                 0x07   // payload
  );
  test_device()->SendScoDataChannelPacket(packet);
  RunLoopUntilIdle();
  EXPECT_EQ(connection()->received_packets().size(), 0u);
}

TEST_F(ScoDataChannelSingleConnectionTest,
       IgnoreNumberOfCompletedPacketsEventForUnknownConnectionHandle) {
  // Queue 1 more than than the max number of packets (1 packet will remain queued).
  for (size_t i = 0; i <= kBufferMaxNumPackets; i++) {
    std::unique_ptr<ScoDataPacket> packet =
        ScoDataPacket::New(kConnectionHandle0, /*payload_size=*/1);
    packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i);

    // The last packet should remain queued.
    if (i < kBufferMaxNumPackets) {
      EXPECT_SCO_PACKET_OUT(test_device(), StaticByteBuffer(LowerBits(kConnectionHandle0),
                                                            UpperBits(kConnectionHandle0),
                                                            0x01,  // payload length
                                                            static_cast<uint8_t>(i)));
    }
    connection()->QueuePacket(std::move(packet));
    RunLoopUntilIdle();
  }
  EXPECT_EQ(connection()->queued_packets().size(), 1u);
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  // kConnectionHandle1 is not registered, so this event should be ignored (no packets should be
  // sent).
  test_device()->SendCommandChannelPacket(
      bt::testing::NumberOfCompletedPacketsPacket(kConnectionHandle1, 1));
  RunLoopUntilIdle();
  EXPECT_EQ(connection()->queued_packets().size(), 1u);
}

TEST_F(ScoDataChannelSingleConnectionTest, ReceiveTooSmallPacket) {
  StaticByteBuffer invalid_packet(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0));
  test_device()->SendScoDataChannelPacket(invalid_packet);
  RunLoopUntilIdle();
  // Packet should be ignored.
  EXPECT_EQ(connection()->received_packets().size(), 0u);

  // The next valid packet should not be ignored.
  auto valid_packet = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                       0x01,  // correct payload length
                                       0x01   // payload
  );
  test_device()->SendScoDataChannelPacket(valid_packet);
  RunLoopUntilIdle();
  EXPECT_EQ(connection()->received_packets().size(), 1u);
}

TEST_F(ScoDataChannelSingleConnectionTest, ReceivePacketWithIncorrectHeaderLengthField) {
  auto packet = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                 0x03,  // incorrect payload length
                                 0x00   // payload
  );
  test_device()->SendScoDataChannelPacket(packet);
  RunLoopUntilIdle();
  // Packet should be ignored.
  EXPECT_EQ(connection()->received_packets().size(), 0u);

  // The next valid packet should not be ignored.
  packet = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                            0x01,  // correct payload length
                            0x01   // payload
  );
  test_device()->SendScoDataChannelPacket(packet);
  RunLoopUntilIdle();
  EXPECT_EQ(connection()->received_packets().size(), 1u);
}

TEST_F(ScoDataChannelTest, CvsdConnectionEncodingBits8SampleRate8Khz) {
  int config_count = 0;

  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    EXPECT_EQ(format, ScoCodingFormat::kCvsd);
    EXPECT_EQ(encoding, ScoEncoding::k8Bits);
    EXPECT_EQ(rate, ScoSampleRate::k8Khz);
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  FakeScoConnection connection_0(sco_data_channel(), kConnectionHandle0, kCvsdConnectionParameters);
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
}

TEST_F(ScoDataChannelTest, CvsdConnectionEncodingBits16SampleRate8Khz) {
  int config_count = 0;
  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    EXPECT_EQ(format, ScoCodingFormat::kCvsd);
    EXPECT_EQ(encoding, ScoEncoding::k16Bits);
    EXPECT_EQ(rate, ScoSampleRate::k8Khz);
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  hci_spec::SynchronousConnectionParameters params = kCvsdConnectionParameters;
  params.input_coded_data_size_bits = 16;
  params.output_coded_data_size_bits = 16;
  // Bandwidth = sample size (2 bytes/sample) * sample rate (8000 samples/sec) = 16000 bytes/sec
  params.output_bandwidth = 16000;
  params.input_bandwidth = 16000;
  FakeScoConnection connection(sco_data_channel(), kConnectionHandle0, params);
  sco_data_channel()->RegisterConnection(connection.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
}

TEST_F(ScoDataChannelTest, CvsdConnectionEncodingBits16SampleRate16Khz) {
  int config_count = 0;
  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    EXPECT_EQ(format, ScoCodingFormat::kCvsd);
    EXPECT_EQ(encoding, ScoEncoding::k16Bits);
    EXPECT_EQ(rate, ScoSampleRate::k16Khz);
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  hci_spec::SynchronousConnectionParameters params = kCvsdConnectionParameters;
  params.input_coded_data_size_bits = 16;
  params.output_coded_data_size_bits = 16;
  // Bandwidth = sample size (2 bytes/sample) * sample rate (16,000 samples/sec) = 32,000 bytes/sec
  params.output_bandwidth = 32000;
  params.input_bandwidth = 32000;
  FakeScoConnection connection(sco_data_channel(), kConnectionHandle0, params);
  sco_data_channel()->RegisterConnection(connection.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
}

TEST_F(ScoDataChannelTest, CvsdConnectionInvalidSampleSizeAndRate) {
  int config_count = 0;
  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    EXPECT_EQ(format, ScoCodingFormat::kCvsd);
    EXPECT_EQ(encoding, ScoEncoding::k16Bits);
    EXPECT_EQ(rate, ScoSampleRate::k16Khz);
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  hci_spec::SynchronousConnectionParameters params = kCvsdConnectionParameters;
  // Invalid sample size will be replaced with sample size of 16 bits.
  params.input_coded_data_size_bits = 0u;
  params.output_coded_data_size_bits = 0u;
  // Invalid rate will be replaced with 16kHz
  params.output_bandwidth = 1;
  params.input_bandwidth = 1;
  FakeScoConnection connection(sco_data_channel(), kConnectionHandle0, params);
  sco_data_channel()->RegisterConnection(connection.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
}

TEST_F(ScoDataChannelTest, ConfigureCallbackCalledAfterTransportDestroyedDoesNotUseAfterFree) {
  HciWrapper::StatusCallback config_cb = nullptr;
  set_configure_sco_cb(
      [&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
          HciWrapper::StatusCallback callback) { config_cb = std::move(callback); });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  FakeScoConnection connection(sco_data_channel());
  sco_data_channel()->RegisterConnection(connection.GetWeakPtr());
  EXPECT_TRUE(config_cb);
  EXPECT_EQ(reset_count, 0);

  DeleteTransport();
  RunLoopUntilIdle();

  // Callback should not use-after-free.
  config_cb(ZX_OK);
  RunLoopUntilIdle();
}

TEST_F(ScoDataChannelTest,
       RegisterAndUnregisterFirstConnectionAndRegisterSecondConnectionBeforeFirstConfigCompletes) {
  std::vector<HciWrapper::StatusCallback> config_callbacks;
  set_configure_sco_cb([&](auto, auto, auto, HciWrapper::StatusCallback callback) {
    config_callbacks.emplace_back(std::move(callback));
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  FakeScoConnection connection_0(sco_data_channel());
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());
  EXPECT_EQ(config_callbacks.size(), 1u);
  sco_data_channel()->UnregisterConnection(connection_0.handle());
  EXPECT_EQ(reset_count, 1);

  FakeScoConnection connection_1(sco_data_channel(), kConnectionHandle1);
  auto packet = StaticByteBuffer(LowerBits(kConnectionHandle1), UpperBits(kConnectionHandle1),
                                 0x01,  // payload length
                                 0x00   // payload
  );
  std::unique_ptr<ScoDataPacket> sco_packet = ScoDataPacket::New(/*payload_size=*/1);
  sco_packet->mutable_view()->mutable_data().Write(packet);
  sco_packet->InitializeFromBuffer();
  connection_1.QueuePacket(std::move(sco_packet));

  sco_data_channel()->RegisterConnection(connection_1.GetWeakPtr());
  EXPECT_EQ(config_callbacks.size(), 2u);
  // sco_packet should not be sent yet.
  RunLoopUntilIdle();
  // The first callback completing should not complete the second connection configuration.
  config_callbacks[0](ZX_OK);
  // sco_packet should not be sent yet.
  RunLoopUntilIdle();
  EXPECT_EQ(connection_1.queued_packets().size(), 1u);
  // Queued packet should be sent after second callback called.
  config_callbacks[1](ZX_OK);
  EXPECT_SCO_PACKET_OUT(test_device(), packet);
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());
}

TEST_F(ScoDataChannelSingleConnectionTest,
       ReceiveNumberOfCompletedPacketsEventWithInconsistentNumberOfHandles) {
  // Queue 1 more than than the max number of packets (1 packet will remain queued).
  for (size_t i = 0; i <= kBufferMaxNumPackets; i++) {
    std::unique_ptr<ScoDataPacket> packet =
        ScoDataPacket::New(kConnectionHandle0, /*payload_size=*/1);
    packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i);

    // The last packet should remain queued.
    if (i < kBufferMaxNumPackets) {
      EXPECT_SCO_PACKET_OUT(test_device(), StaticByteBuffer(LowerBits(kConnectionHandle0),
                                                            UpperBits(kConnectionHandle0),
                                                            0x01,  // payload length
                                                            static_cast<uint8_t>(i)));
    }
    connection()->QueuePacket(std::move(packet));
    RunLoopUntilIdle();
  }
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());

  // The handle in the event should still be processed even though the number of handles is wrong.
  EXPECT_SCO_PACKET_OUT(
      test_device(), StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                      0x01,  // payload length
                                      static_cast<uint8_t>(kBufferMaxNumPackets)));

  constexpr uint16_t num_packets = 1;
  StaticByteBuffer event{0x13,
                         0x05,  // Number Of Completed Packet HCI event header, parameters length
                         0x09,  // Incorrect number of handles
                         LowerBits(kConnectionHandle0),
                         UpperBits(kConnectionHandle0),
                         LowerBits(num_packets),
                         UpperBits(num_packets)};
  test_device()->SendCommandChannelPacket(event);
  RunLoopUntilIdle();
  EXPECT_TRUE(test_device()->AllExpectedScoPacketsSent());
}

TEST_F(ScoDataChannelTest, RegisterTwoConnectionsAndFirstConfigurationFails) {
  int config_count = 0;
  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    if (config_count == 1) {
      callback(ZX_ERR_INVALID_ARGS);
      return;
    }
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  FakeScoConnection connection_0(sco_data_channel());
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
  EXPECT_EQ(connection_0.hci_error_count(), 0);

  FakeScoConnection connection_1(sco_data_channel(), kConnectionHandle1);
  sco_data_channel()->RegisterConnection(connection_1.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);

  // The first configuration error should be processed & the configuration of connection_1 should
  // succeed.
  RunLoopUntilIdle();
  EXPECT_EQ(connection_0.hci_error_count(), 1);
  EXPECT_EQ(config_count, 2);
  EXPECT_EQ(reset_count, 0);

  auto packet_0 = StaticByteBuffer(LowerBits(kConnectionHandle0), UpperBits(kConnectionHandle0),
                                   0x01,  // payload length
                                   0x00   // payload
  );
  test_device()->SendScoDataChannelPacket(packet_0);
  RunLoopUntilIdle();
  // packet_0 should not be received since connection_0 failed configuration and was unregistered.
  ASSERT_EQ(connection_0.received_packets().size(), 0u);

  auto packet_1 = StaticByteBuffer(LowerBits(kConnectionHandle1), UpperBits(kConnectionHandle1),
                                   0x01,  // payload length
                                   0x01   // payload
  );
  test_device()->SendScoDataChannelPacket(packet_1);
  RunLoopUntilIdle();
  ASSERT_EQ(connection_1.received_packets().size(), 1u);

  // There are no active connections now (+1 to reset_count).
  sco_data_channel()->UnregisterConnection(connection_1.handle());
  EXPECT_EQ(config_count, 2);
  EXPECT_EQ(reset_count, 1);
}

TEST_F(ScoDataChannelTest, UnsupportedCodingFormatTreatedAsCvsd) {
  int config_count = 0;
  set_configure_sco_cb([&](ScoCodingFormat format, ScoEncoding encoding, ScoSampleRate rate,
                           HciWrapper::StatusCallback callback) {
    config_count++;
    EXPECT_EQ(format, ScoCodingFormat::kCvsd);
    callback(ZX_OK);
  });

  int reset_count = 0;
  set_reset_sco_cb([&](HciWrapper::StatusCallback callback) {
    reset_count++;
    callback(ZX_OK);
  });

  hci_spec::SynchronousConnectionParameters params = kCvsdConnectionParameters;
  params.output_coding_format.coding_format = hci_spec::CodingFormat::kMuLaw;
  params.input_coding_format.coding_format = hci_spec::CodingFormat::kMuLaw;

  FakeScoConnection connection_0(sco_data_channel(), kConnectionHandle0, params);
  sco_data_channel()->RegisterConnection(connection_0.GetWeakPtr());
  EXPECT_EQ(config_count, 1);
  EXPECT_EQ(reset_count, 0);
}

}  // namespace
}  // namespace bt::hci