// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/gap/peer.h"

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <pw_async/fake_dispatcher_fixture.h>

#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/common/advertising_data.h"
#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/common/byte_buffer.h"
#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/common/manufacturer_names.h"
#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/hci-spec/util.h"
#include "src/connectivity/bluetooth/core/bt-host/public/pw_bluetooth_sapphire/internal/host/testing/inspect_util.h"

namespace bt::gap {
namespace {

#ifndef NINSPECT
using namespace inspect::testing;
using bt::testing::GetInspectValue;
using bt::testing::ReadInspect;

constexpr uint16_t kManufacturer = 0x0001;
constexpr uint16_t kSubversion = 0x0002;
#endif  // NINSPECT

const StaticByteBuffer kAdvData(0x05,  // Length
                                0x09,  // AD type: Complete Local Name
                                'T',
                                'e',
                                's',
                                't');

const StaticByteBuffer kInvalidAdvData{
    // 32 bit service UUIDs are supposed to be 4 bytes, but the value in this
    // TLV field is only 3
    // bytes long, hence the AdvertisingData is not valid.
    0x04,
    static_cast<uint8_t>(DataType::kComplete32BitServiceUuids),
    0x01,
    0x02,
    0x03,
};

const bt::sm::LTK kLTK;

const DeviceAddress kAddrLePublic(DeviceAddress::Type::kLEPublic,
                                  {1, 2, 3, 4, 5, 6});
const DeviceAddress kAddrLeRandom(DeviceAddress::Type::kLERandom,
                                  {1, 2, 3, 4, 5, 6});
const DeviceAddress kAddrBrEdr(DeviceAddress::Type::kBREDR,
                               {0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA});
// LE Public Device Address that has the same value as a BR/EDR BD_ADDR, e.g. on
// a dual-mode device.
const DeviceAddress kAddrLeAlias(DeviceAddress::Type::kLEPublic,
                                 {0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA});

const bt::sm::LTK kSecureBrEdrKey(
    sm::SecurityProperties(/*encrypted=*/true,
                           /*authenticated=*/true,
                           /*secure_connections=*/true,
                           sm::kMaxEncryptionKeySize),
    hci_spec::LinkKey(UInt128{4}, 5, 6));

class PeerTest : public pw::async::test::FakeDispatcherFixture {
 public:
  PeerTest() = default;

  void SetUp() override {
    // Set up a default peer.
    SetUpPeer(/*address=*/kAddrLePublic, /*connectable=*/true);
  }

  void TearDown() override { peer_.reset(); }

 protected:
  // Can be used to override or reset the default peer. Resets metrics to
  // prevent interference between peers (e.g. by metrics updated in
  // construction).
  void SetUpPeer(const DeviceAddress& address, bool connectable) {
    address_ = address;
    peer_ = std::make_unique<Peer>(
        fit::bind_member<&PeerTest::NotifyListenersCallback>(this),
        fit::bind_member<&PeerTest::UpdateExpiryCallback>(this),
        fit::bind_member<&PeerTest::DualModeCallback>(this),
        fit::bind_member<&PeerTest::StoreLowEnergyBondCallback>(this),
        PeerId(1),
        address_,
        connectable,
        &metrics_,
        dispatcher());
    peer_->AttachInspect(peer_inspector_.GetRoot());
    // Reset metrics as they should only apply to the new peer under test.
    metrics_.AttachInspect(metrics_inspector_.GetRoot());
  }
  Peer& peer() { return *peer_; }

#ifndef NINSPECT
  inspect::Hierarchy ReadPeerInspect() { return ReadInspect(peer_inspector_); }

  std::string InspectLowEnergyConnectionState() {
    std::optional<std::string> val =
        GetInspectValue<inspect::StringPropertyValue>(
            peer_inspector_,
            {"peer",
             "le_data",
             Peer::LowEnergyData::kInspectConnectionStateName});
    BT_ASSERT(val);
    return *val;
  }

  int64_t InspectAdvertisingDataParseFailureCount() {
    std::optional<int64_t> val = GetInspectValue<inspect::IntPropertyValue>(
        peer_inspector_,
        {"peer",
         "le_data",
         Peer::LowEnergyData::kInspectAdvertisingDataParseFailureCountName});
    BT_ASSERT(val);
    return *val;
  }

  std::string InspectLastAdvertisingDataParseFailure() {
    std::optional<std::string> val =
        GetInspectValue<inspect::StringPropertyValue>(
            peer_inspector_,
            {"peer",
             "le_data",
             Peer::LowEnergyData::kInspectLastAdvertisingDataParseFailureName});
    BT_ASSERT(val);
    return *val;
  }

  uint64_t MetricsLowEnergyConnections() {
    std::optional<uint64_t> val = GetInspectValue<inspect::UintPropertyValue>(
        metrics_inspector_, {"metrics", "le", "connection_events"});
    BT_ASSERT(val);
    return *val;
  }

  uint64_t MetricsLowEnergyDisconnections() {
    std::optional<uint64_t> val = GetInspectValue<inspect::UintPropertyValue>(
        metrics_inspector_, {"metrics", "le", "disconnection_events"});
    BT_ASSERT(val);
    return *val;
  }

  std::string InspectBrEdrConnectionState() {
    std::optional<std::string> val =
        GetInspectValue<inspect::StringPropertyValue>(
            peer_inspector_,
            {"peer",
             "bredr_data",
             Peer::BrEdrData::kInspectConnectionStateName});
    BT_ASSERT(val);
    return *val;
  }

  uint64_t MetricsBrEdrConnections() {
    std::optional<uint64_t> val = GetInspectValue<inspect::UintPropertyValue>(
        metrics_inspector_, {"metrics", "bredr", "connection_events"});
    BT_ASSERT(val);
    return *val;
  }

  uint64_t MetricsBrEdrDisconnections() {
    std::optional<uint64_t> val = GetInspectValue<inspect::UintPropertyValue>(
        metrics_inspector_, {"metrics", "bredr", "disconnection_events"});
    BT_ASSERT(val);
    return *val;
  }
#endif  // NINSPECT

  void set_notify_listeners_cb(Peer::NotifyListenersCallback cb) {
    notify_listeners_cb_ = std::move(cb);
  }
  void set_update_expiry_cb(Peer::PeerCallback cb) {
    update_expiry_cb_ = std::move(cb);
  }
  void set_dual_mode_cb(Peer::PeerCallback cb) {
    dual_mode_cb_ = std::move(cb);
  }
  void set_store_le_bond_cb(Peer::StoreLowEnergyBondCallback cb) {
    store_le_bond_cb_ = std::move(cb);
  }

 private:
  void NotifyListenersCallback(const Peer& peer,
                               Peer::NotifyListenersChange change) {
    if (notify_listeners_cb_) {
      notify_listeners_cb_(peer, change);
    }
  }

  void UpdateExpiryCallback(const Peer& peer) {
    if (update_expiry_cb_) {
      update_expiry_cb_(peer);
    }
  }

  void DualModeCallback(const Peer& peer) {
    if (dual_mode_cb_) {
      dual_mode_cb_(peer);
    }
  }

  bool StoreLowEnergyBondCallback(const sm::PairingData& data) {
    if (store_le_bond_cb_) {
      return store_le_bond_cb_(data);
    }
    return false;
  }

  std::unique_ptr<Peer> peer_;
  DeviceAddress address_;
  Peer::NotifyListenersCallback notify_listeners_cb_;
  Peer::PeerCallback update_expiry_cb_;
  Peer::PeerCallback dual_mode_cb_;
  Peer::StoreLowEnergyBondCallback store_le_bond_cb_;
  inspect::Inspector metrics_inspector_;
  PeerMetrics metrics_;
  inspect::Inspector peer_inspector_;
};

class PeerDeathTest : public PeerTest {};

#ifndef NINSPECT
TEST_F(PeerTest, InspectHierarchy) {
  peer().set_version(pw::bluetooth::emboss::CoreSpecificationVersion::V5_0,
                     kManufacturer,
                     kSubversion);

  peer().RegisterName("Sapphire💖", Peer::NameSource::kGenericAccessService);

  peer().MutLe();
  ASSERT_TRUE(peer().le().has_value());

  peer().MutLe().SetFeatures(hci_spec::LESupportedFeatures{0x0000000000000001});

  peer().MutBrEdr().AddService(UUID(uint16_t{0x110b}));

  auto bredr_data_matcher = AllOf(NodeMatches(
      AllOf(NameMatches(Peer::BrEdrData::kInspectNodeName),
            PropertyList(UnorderedElementsAre(
                StringIs(Peer::BrEdrData::kInspectConnectionStateName,
                         Peer::ConnectionStateToString(
                             peer().bredr()->connection_state())),
                StringIs(Peer::BrEdrData::kInspectServicesName,
                         "{ 0000110b-0000-1000-8000-00805f9b34fb }"))))));

  auto le_data_matcher = AllOf(NodeMatches(AllOf(
      NameMatches(Peer::LowEnergyData::kInspectNodeName),
      PropertyList(UnorderedElementsAre(
          StringIs(
              Peer::LowEnergyData::kInspectConnectionStateName,
              Peer::ConnectionStateToString(peer().le()->connection_state())),
          IntIs(
              Peer::LowEnergyData::kInspectAdvertisingDataParseFailureCountName,
              0),
          StringIs(
              Peer::LowEnergyData::kInspectLastAdvertisingDataParseFailureName,
              ""),
          BoolIs(Peer::LowEnergyData::kInspectBondDataName,
                 peer().le()->bonded()),
          StringIs(Peer::LowEnergyData::kInspectFeaturesName,
                   "0x0000000000000001"))))));

  auto peer_matcher = AllOf(
      NodeMatches(PropertyList(UnorderedElementsAre(
          StringIs(Peer::kInspectPeerIdName, peer().identifier().ToString()),
          StringIs(Peer::kInspectPeerNameName,
                   peer().name().value() + " [source: " +
                       Peer::NameSourceToString(
                           Peer::NameSource::kGenericAccessService) +
                       "]"),
          StringIs(Peer::kInspectTechnologyName,
                   TechnologyTypeToString(peer().technology())),
          StringIs(Peer::kInspectAddressName, peer().address().ToString()),
          BoolIs(Peer::kInspectConnectableName, peer().connectable()),
          BoolIs(Peer::kInspectTemporaryName, peer().temporary()),
          StringIs(Peer::kInspectFeaturesName, peer().features().ToString()),
          StringIs(Peer::kInspectVersionName,
                   hci_spec::HCIVersionToString(peer().version().value())),
          StringIs(Peer::kInspectManufacturerName,
                   GetManufacturerName(kManufacturer))))),
      ChildrenMatch(UnorderedElementsAre(bredr_data_matcher, le_data_matcher)));
  // clang-format on
  inspect::Hierarchy hierarchy = ReadPeerInspect();
  EXPECT_THAT(hierarchy,
              AllOf(ChildrenMatch(UnorderedElementsAre(peer_matcher))));
}
#endif  // NINSPECT

#ifndef NINSPECT
TEST_F(PeerTest, SetBrEdrBondDataUpdatesInspectProperties) {
  const char* const kInspectLevelPropertyName = "level";
  const char* const kInspectEncryptedPropertyName = "encrypted";
  const char* const kInspectSecureConnectionsPropertyName =
      "secure_connections";
  const char* const kInspectAuthenticatedPropertyName = "authenticated";
  const char* const kInspectKeyTypePropertyName = "key_type";

  peer().set_version(pw::bluetooth::emboss::CoreSpecificationVersion::V5_0,
                     kManufacturer,
                     kSubversion);

  peer().RegisterName("Sapphire💖", Peer::NameSource::kGenericAccessService);

  peer().MutLe();
  ASSERT_TRUE(peer().le().has_value());

  peer().MutLe().SetFeatures(hci_spec::LESupportedFeatures{0x0000000000000001});

  peer().MutBrEdr().AddService(UUID(uint16_t{0x110b}));
  peer().MutBrEdr().SetBondData(kLTK);

  // clang-format off
  auto bredr_data_matcher = AllOf(
    NodeMatches(AllOf(
      NameMatches(Peer::BrEdrData::kInspectNodeName),
      PropertyList(UnorderedElementsAre(
        StringIs(Peer::BrEdrData::kInspectConnectionStateName,
                 Peer::ConnectionStateToString(peer().bredr()->connection_state())),
        StringIs(Peer::BrEdrData::kInspectServicesName, "{ 0000110b-0000-1000-8000-00805f9b34fb }")
        )))));

  auto le_data_matcher = AllOf(
    NodeMatches(AllOf(
      NameMatches(Peer::LowEnergyData::kInspectNodeName),
      PropertyList(UnorderedElementsAre(
        StringIs(Peer::LowEnergyData::kInspectConnectionStateName,
                 Peer::ConnectionStateToString(peer().le()->connection_state())),
        IntIs(Peer::LowEnergyData::kInspectAdvertisingDataParseFailureCountName, 0),
        StringIs(Peer::LowEnergyData::kInspectLastAdvertisingDataParseFailureName, ""),
        BoolIs(Peer::LowEnergyData::kInspectBondDataName, peer().le()->bonded()),
        StringIs(Peer::LowEnergyData::kInspectFeaturesName, "0x0000000000000001")
        )))));

  auto peer_matcher = AllOf(
    NodeMatches(
      PropertyList(UnorderedElementsAre(
        StringIs(Peer::kInspectPeerIdName, peer().identifier().ToString()),
        StringIs(Peer::kInspectPeerNameName, peer().name().value() + " [source: " + Peer::NameSourceToString(Peer::NameSource::kGenericAccessService) + "]"),
        StringIs(Peer::kInspectTechnologyName, TechnologyTypeToString(peer().technology())),
        StringIs(Peer::kInspectAddressName, peer().address().ToString()),
        BoolIs(Peer::kInspectConnectableName, peer().connectable()),
        BoolIs(Peer::kInspectTemporaryName, peer().temporary()),
        StringIs(Peer::kInspectFeaturesName, peer().features().ToString()),
        StringIs(Peer::kInspectVersionName, hci_spec::HCIVersionToString(peer().version().value())),
        StringIs(Peer::kInspectManufacturerName, GetManufacturerName(kManufacturer))
        ))),
    ChildrenMatch(UnorderedElementsAre(bredr_data_matcher, le_data_matcher)));
  // clang-format on
  inspect::Hierarchy hierarchy = ReadPeerInspect();
  EXPECT_THAT(hierarchy,
              AllOf(ChildrenMatch(UnorderedElementsAre(peer_matcher))));

  peer().MutBrEdr().SetBondData(kSecureBrEdrKey);

  const sm::SecurityProperties security_properties =
      peer().bredr()->link_key().value().security();
  auto link_key_matcher = AllOf(NodeMatches(AllOf(
      NameMatches("link_key"),
      PropertyList(UnorderedElementsAre(
          StringIs(kInspectLevelPropertyName,
                   LevelToString(security_properties.level())),
          BoolIs(kInspectEncryptedPropertyName,
                 security_properties.encrypted()),
          BoolIs(kInspectSecureConnectionsPropertyName,
                 security_properties.secure_connections()),
          BoolIs(kInspectAuthenticatedPropertyName,
                 security_properties.authenticated()),
          StringIs(kInspectKeyTypePropertyName,
                   hci_spec::LinkKeyTypeToString(
                       security_properties.GetLinkKeyType().value())))))));

  auto bredr_data_matcher2 =
      AllOf(NodeMatches(AllOf(
                NameMatches(Peer::BrEdrData::kInspectNodeName),
                PropertyList(UnorderedElementsAre(
                    StringIs(Peer::BrEdrData::kInspectConnectionStateName,
                             Peer::ConnectionStateToString(
                                 peer().bredr()->connection_state())),
                    StringIs(Peer::BrEdrData::kInspectServicesName,
                             "{ 0000110b-0000-1000-8000-00805f9b34fb }"))))),
            ChildrenMatch(UnorderedElementsAre(link_key_matcher)));

  auto le_data_matcher2 = AllOf(NodeMatches(AllOf(
      NameMatches(Peer::LowEnergyData::kInspectNodeName),
      PropertyList(UnorderedElementsAre(
          StringIs(
              Peer::LowEnergyData::kInspectConnectionStateName,
              Peer::ConnectionStateToString(peer().le()->connection_state())),
          IntIs(
              Peer::LowEnergyData::kInspectAdvertisingDataParseFailureCountName,
              0),
          StringIs(
              Peer::LowEnergyData::kInspectLastAdvertisingDataParseFailureName,
              ""),
          BoolIs(Peer::LowEnergyData::kInspectBondDataName,
                 peer().le()->bonded()),
          StringIs(Peer::LowEnergyData::kInspectFeaturesName,
                   "0x0000000000000001"))))));

  auto peer_matcher2 = AllOf(
      NodeMatches(PropertyList(UnorderedElementsAre(
          StringIs(Peer::kInspectPeerIdName, peer().identifier().ToString()),
          StringIs(Peer::kInspectPeerNameName,
                   peer().name().value() + " [source: " +
                       Peer::NameSourceToString(
                           Peer::NameSource::kGenericAccessService) +
                       "]"),
          StringIs(Peer::kInspectTechnologyName,
                   TechnologyTypeToString(peer().technology())),
          StringIs(Peer::kInspectAddressName, peer().address().ToString()),
          BoolIs(Peer::kInspectConnectableName, peer().connectable()),
          BoolIs(Peer::kInspectTemporaryName, peer().temporary()),
          StringIs(Peer::kInspectFeaturesName, peer().features().ToString()),
          StringIs(Peer::kInspectVersionName,
                   hci_spec::HCIVersionToString(peer().version().value())),
          StringIs(Peer::kInspectManufacturerName,
                   GetManufacturerName(kManufacturer))))),
      ChildrenMatch(
          UnorderedElementsAre(bredr_data_matcher2, le_data_matcher2)));
  // clang-format on
  hierarchy = ReadPeerInspect();
  EXPECT_THAT(hierarchy,
              AllOf(ChildrenMatch(UnorderedElementsAre(peer_matcher2))));
}
#endif  // NINSPECT

TEST_F(PeerTest, BrEdrDataAddServiceNotifiesListeners) {
  // Initialize BrEdrData.
  peer().MutBrEdr();
  ASSERT_TRUE(peer().bredr()->services().empty());

  bool listener_notified = false;
  set_notify_listeners_cb([&](auto&, Peer::NotifyListenersChange change) {
    listener_notified = true;
    // Non-bonded peer should not update bond
    EXPECT_EQ(Peer::NotifyListenersChange::kBondNotUpdated, change);
  });

  constexpr UUID kServiceUuid;
  peer().MutBrEdr().AddService(kServiceUuid);
  EXPECT_TRUE(listener_notified);
  EXPECT_EQ(1u, peer().bredr()->services().count(kServiceUuid));

  // De-duplicate subsequent additions of the same service.
  listener_notified = false;
  peer().MutBrEdr().AddService(kServiceUuid);
  EXPECT_FALSE(listener_notified);
}

TEST_F(PeerTest, BrEdrDataAddServiceOnBondedPeerNotifiesListenersToUpdateBond) {
  // Initialize BrEdrData.
  peer().MutBrEdr().SetBondData({});
  ASSERT_TRUE(peer().bredr()->services().empty());

  bool listener_notified = false;
  set_notify_listeners_cb([&](auto&, Peer::NotifyListenersChange change) {
    listener_notified = true;
    // Bonded peer should update bond
    EXPECT_EQ(Peer::NotifyListenersChange::kBondUpdated, change);
  });

  peer().MutBrEdr().AddService(UUID());
  EXPECT_TRUE(listener_notified);
}

TEST_F(PeerTest,
       LowEnergyDataSetAdvDataWithInvalidUtf8NameDoesNotUpdatePeerName) {
  peer().MutLe();  // Initialize LowEnergyData.
  ASSERT_FALSE(peer().name().has_value());

  bool listener_notified = false;
  set_notify_listeners_cb(
      [&](auto&, Peer::NotifyListenersChange) { listener_notified = true; });

  const StaticByteBuffer kAdvData(
      0x05,  // Length
      0x09,  // AD type: Complete Local Name
      'T',
      'e',
      's',
      0xFF  // 0xFF should not appear in a valid UTF-8 string
  );

  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0, kAdvData, pw::chrono::SystemClock::time_point());
  EXPECT_TRUE(listener_notified);  // Fresh AD still results in an update
  EXPECT_FALSE(peer().name().has_value());
}

TEST_F(PeerTest, BrEdrDataSetEirDataWithInvalidUtf8NameDoesNotUpdatePeerName) {
  peer().MutBrEdr();  // Initialize BrEdrData.
  ASSERT_FALSE(peer().name().has_value());

  bool listener_notified = false;
  set_notify_listeners_cb(
      [&](auto&, Peer::NotifyListenersChange) { listener_notified = true; });

  const StaticByteBuffer kEirData(
      0x05,  // Length
      0x09,  // AD type: Complete Local Name
      'T',
      'e',
      's',
      0xFF  // 0xFF should not appear in a valid UTF-8 string
  );

  StaticPacket<pw::bluetooth::emboss::ExtendedInquiryResultEventWriter> eirep;
  eirep.view().num_responses().Write(1);
  eirep.view().bd_addr().CopyFrom(peer().address().value().view());
  eirep.view().extended_inquiry_response().BackingStorage().CopyFrom(
      ::emboss::support::ReadOnlyContiguousBuffer(&kEirData), kEirData.size());

  peer().MutBrEdr().SetInquiryData(eirep.view());
  EXPECT_TRUE(listener_notified);  // Fresh EIR data still results in an update
  EXPECT_FALSE(peer().name().has_value());
}

TEST_F(PeerTest, RegisterNameWithInvalidUtf8NameDoesNotUpdatePeerName) {
  ASSERT_FALSE(peer().name().has_value());

  bool listener_notified = false;
  set_notify_listeners_cb(
      [&](auto&, Peer::NotifyListenersChange) { listener_notified = true; });

  const std::string kName =
      "Tes\xFF\x01";  // 0xFF should not appear in a valid UTF-8 string
  peer().RegisterName(kName);
  EXPECT_FALSE(listener_notified);
  EXPECT_FALSE(peer().name().has_value());
}

TEST_F(PeerTest, LowEnergyAdvertisingDataTimestamp) {
  EXPECT_FALSE(peer().MutLe().parsed_advertising_data_timestamp());
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0,
      kAdvData,
      pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(1)));
  ASSERT_TRUE(peer().MutLe().parsed_advertising_data_timestamp());
  EXPECT_EQ(peer().MutLe().parsed_advertising_data_timestamp().value(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(1)));

  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0,
      kAdvData,
      pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  ASSERT_TRUE(peer().MutLe().parsed_advertising_data_timestamp());
  EXPECT_EQ(peer().MutLe().parsed_advertising_data_timestamp().value(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));

  // SetAdvertisingData with data that fails to parse should not update the
  // advertising data timestamp.
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0,
      kInvalidAdvData,
      pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(3)));
  ASSERT_TRUE(peer().MutLe().parsed_advertising_data_timestamp());
  EXPECT_EQ(peer().MutLe().parsed_advertising_data_timestamp().value(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
}

TEST_F(PeerTest, SettingLowEnergyAdvertisingDataUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0,
      kAdvData,
      pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(1)));
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, RegisteringLowEnergyInitializingConnectionUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  Peer::InitializingConnectionToken token =
      peer().MutLe().RegisterInitializingConnection();
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, SettingLowEnergyBondDataUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  sm::PairingData data;
  data.peer_ltk = kLTK;
  data.local_ltk = kLTK;
  peer().MutLe().SetBondData(data);
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, RegisteringBrEdrInitializingConnectionUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  Peer::InitializingConnectionToken token =
      peer().MutBrEdr().RegisterInitializingConnection();
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, SettingInquiryDataUpdatesLastUpdated) {
  SetUpPeer(/*address=*/kAddrLeAlias, /*connectable=*/true);
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  StaticPacket<pw::bluetooth::emboss::InquiryResultWriter> ir;
  ir.view().bd_addr().CopyFrom(kAddrLeAlias.value().view());
  peer().MutBrEdr().SetInquiryData(ir.view());
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, SettingBrEdrBondDataUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  peer().MutBrEdr().SetBondData(kSecureBrEdrKey);
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, SettingAddingBrEdrServiceUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  peer().MutBrEdr().AddService(UUID(uint16_t{0x110b}));
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, RegisteringNameUpdatesLastUpdated) {
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  int notify_count = 0;
  set_notify_listeners_cb([&](const Peer&, Peer::NotifyListenersChange) {
    EXPECT_EQ(peer().last_updated(),
              pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
    notify_count++;
  });

  RunFor(pw::chrono::SystemClock::duration(2));
  peer().RegisterName("name");
  EXPECT_EQ(peer().last_updated(),
            pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(2)));
  EXPECT_GE(notify_count, 1);
}

TEST_F(PeerTest, RegisterAndUnregisterTwoLowEnergyConnections) {
  SetUpPeer(/*address=*/kAddrLeRandom, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::ConnectionToken> token_0 =
      peer().MutLe().RegisterConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
  EXPECT_EQ(MetricsLowEnergyConnections(), 1u);
#endif  // NINSPECT

  std::optional<Peer::ConnectionToken> token_1 =
      peer().MutLe().RegisterConnection();
  // The second connection should not update expiry or notify.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
  // Although the second connection does not change the high-level connection
  // state, we track it in metrics to support multiple connections to the same
  // peer.
  EXPECT_EQ(MetricsLowEnergyConnections(), 2u);
  EXPECT_EQ(MetricsLowEnergyDisconnections(), 0u);
#endif  // NINSPECT

  token_0.reset();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
  EXPECT_EQ(MetricsLowEnergyDisconnections(), 1u);
#endif  // NINSPECT

  token_1.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 3);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
  EXPECT_EQ(MetricsLowEnergyDisconnections(), 2u);
#endif  // NINSPECT
}

TEST_F(PeerTest, RegisterAndUnregisterLowEnergyConnectionsWhenIdentityKnown) {
  EXPECT_TRUE(peer().identity_known());
  std::optional<Peer::ConnectionToken> token =
      peer().MutLe().RegisterConnection();
  EXPECT_FALSE(peer().temporary());
  token.reset();
  // The peer's identity is known, so it should stay non-temporary upon
  // disconnection.
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest,
       RegisterAndUnregisterInitializingLowEnergyConnectionsWhenIdentityKnown) {
  EXPECT_TRUE(peer().identity_known());
  std::optional<Peer::InitializingConnectionToken> token =
      peer().MutLe().RegisterInitializingConnection();
  EXPECT_FALSE(peer().temporary());
  token.reset();
  // The peer's identity is known, so it should stay non-temporary upon
  // disconnection.
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest,
       RegisterAndUnregisterLowEnergyConnectionDuringInitializingConnection) {
  SetUpPeer(/*address=*/kAddrLeRandom, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::InitializingConnectionToken> init_token =
      peer().MutLe().RegisterInitializingConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutLe().RegisterConnection();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 3);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 4);
  EXPECT_EQ(notify_count, 4);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  init_token.reset();
  EXPECT_EQ(update_expiry_count, 5);
  EXPECT_EQ(notify_count, 5);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest,
       RegisterAndUnregisterInitializingLowEnergyConnectionDuringConnection) {
  SetUpPeer(/*address=*/kAddrLeRandom, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutLe().RegisterConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  std::optional<Peer::InitializingConnectionToken> init_token =
      peer().MutLe().RegisterInitializingConnection();
  // Initializing connections should not affect the expiry or notify listeners
  // for peers that are already connected.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  init_token.reset();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectLowEnergyConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 3);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest, RegisterAndUnregisterTwoLowEnergyInitializingConnections) {
  SetUpPeer(/*address=*/kAddrLeRandom, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::InitializingConnectionToken> token_0 =
      peer().MutLe().RegisterInitializingConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  std::optional<Peer::InitializingConnectionToken> token_1 =
      peer().MutLe().RegisterInitializingConnection();
  // The second initializing connection should not update expiry or notify.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  token_0.reset();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT
  token_1.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 3);
  // The peer's identity is not known, so it should become temporary upon
  // disconnection.
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectLowEnergyConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest, MovingLowEnergyConnectionTokenWorksAsExpected) {
  std::optional<Peer::ConnectionToken> token_0 =
      peer().MutLe().RegisterConnection();
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);

  std::optional<Peer::ConnectionToken> token_1 = std::move(token_0);
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);

  token_0.reset();
  EXPECT_EQ(peer().le()->connection_state(), Peer::ConnectionState::kConnected);

  token_1.reset();
  EXPECT_EQ(peer().le()->connection_state(),
            Peer::ConnectionState::kNotConnected);
}

TEST_F(PeerTest, RegisterNamesWithVariousSources) {
  ASSERT_FALSE(peer().name().has_value());
  ASSERT_TRUE(peer().RegisterName("test", Peer::kAdvertisingDataComplete));

  // Test that name with lower source priority does not replace stored name with
  // higher priority.
  ASSERT_FALSE(peer().RegisterName("test", Peer::kUnknown));

  // Test that name with higher source priority replaces stored name with lower
  // priority.
  ASSERT_TRUE(peer().RegisterName("test", Peer::kGenericAccessService));

  // Test that stored name is not replaced with an identical name from an
  // identical source.
  ASSERT_FALSE(peer().RegisterName("test", Peer::kGenericAccessService));

  // Test that stored name is replaced by a different name from the same source.
  ASSERT_TRUE(
      peer().RegisterName("different_name", Peer::kGenericAccessService));
}

TEST_F(PeerTest, SetValidAdvertisingData) {
  constexpr const char* kLocalName = "Test";
  StaticByteBuffer raw_data{
      // Length - Type - Value formatted Local name
      0x05,
      static_cast<uint8_t>(DataType::kCompleteLocalName),
      kLocalName[0],
      kLocalName[1],
      kLocalName[2],
      kLocalName[3],
  };
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/32, raw_data, pw::chrono::SystemClock::time_point());
  // Setting an AdvertisingData with a local name field should update the peer's
  // local name.
  ASSERT_TRUE(peer().name().has_value());
  EXPECT_EQ(kLocalName, peer().name().value());
  EXPECT_EQ(Peer::NameSource::kAdvertisingDataComplete, peer().name_source());
#ifndef NINSPECT
  EXPECT_EQ(0, InspectAdvertisingDataParseFailureCount());
  EXPECT_EQ("", InspectLastAdvertisingDataParseFailure());
#endif  // NINSPECT
}

TEST_F(PeerTest, SetShortenedLocalName) {
  constexpr const char* kLocalName = "Test";
  StaticByteBuffer raw_data{
      // Length - Type - Value formatted Local name
      0x05,
      static_cast<uint8_t>(DataType::kShortenedLocalName),
      kLocalName[0],
      kLocalName[1],
      kLocalName[2],
      kLocalName[3],
  };
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/32, raw_data, pw::chrono::SystemClock::time_point());
  ASSERT_TRUE(peer().name().has_value());
  EXPECT_EQ(kLocalName, peer().name().value());
  EXPECT_EQ(Peer::NameSource::kAdvertisingDataShortened, peer().name_source());
}

TEST_F(PeerTest, SetInvalidAdvertisingData) {
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/32, kInvalidAdvData, pw::chrono::SystemClock::time_point());

#ifndef NINSPECT
  EXPECT_EQ(1, InspectAdvertisingDataParseFailureCount());
  EXPECT_EQ(AdvertisingData::ParseErrorToString(
                AdvertisingData::ParseError::kUuidsMalformed),
            InspectLastAdvertisingDataParseFailure());
#endif  // NINSPECT
}

TEST_F(PeerDeathTest, RegisterTwoBrEdrConnectionsAsserts) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);
  std::optional<Peer::ConnectionToken> token_0 =
      peer().MutBrEdr().RegisterConnection();
  ASSERT_DEATH_IF_SUPPORTED(
      {
        std::optional<Peer::ConnectionToken> token_1 =
            peer().MutBrEdr().RegisterConnection();
      },
      ".*already registered.*");
}

TEST_F(PeerTest,
       RegisterAndUnregisterInitializingBrEdrConnectionLeavesPeerTemporary) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);
  EXPECT_TRUE(peer().identity_known());
  std::optional<Peer::InitializingConnectionToken> token =
      peer().MutBrEdr().RegisterInitializingConnection();
  EXPECT_FALSE(peer().temporary());
  token.reset();
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest, RegisterAndUnregisterBrEdrConnectionWithoutBonding) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutBrEdr().RegisterConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectBrEdrConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 3);
  // BR/EDR peers should become non-temporary after disconnecting if not bonded.
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest, RegisterAndUnregisterBrEdrConnectionWithBonding) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutBrEdr().RegisterConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectBrEdrConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  peer().MutBrEdr().SetBondData(kSecureBrEdrKey);
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 3);

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 4);
  // Bonded BR/EDR peers should remain non-temporary after disconnecting.
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest,
       RegisterAndUnregisterBrEdrConnectionDuringInitializingConnection) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::InitializingConnectionToken> init_token =
      peer().MutBrEdr().RegisterInitializingConnection();
  // Expiry is updated for state change + becoming non-temporary.
  EXPECT_EQ(update_expiry_count, 2);
  // 1 notification for becoming non-temporary.
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  // The connection state should not change when registering a connection
  // because the peer is still initializing.
  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutBrEdr().RegisterConnection();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  init_token.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 1);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(
    PeerTest,
    RegisterBrEdrConnectionDuringInitializingConnectionAndThenCompleteInitialization) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::InitializingConnectionToken> init_token =
      peer().MutBrEdr().RegisterInitializingConnection();
  // Expiry is updated for state change + becoming non-temporary.
  EXPECT_EQ(update_expiry_count, 2);
  // 1 notification for becoming non-temporary.
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  // The connection state should not change when registering a connection
  // because the peer is still initializing.
  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutBrEdr().RegisterConnection();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  // When initialization completes, the connection state should become
  // kConnected.
  init_token.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectBrEdrConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  conn_token.reset();
  EXPECT_EQ(update_expiry_count, 4);
  EXPECT_EQ(notify_count, 3);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  EXPECT_EQ(
      InspectBrEdrConnectionState(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerDeathTest,
       RegisterInitializingBrEdrConnectionDuringConnectionAsserts) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::ConnectionToken> conn_token =
      peer().MutBrEdr().RegisterConnection();
  // A notification and expiry update are sent when the peer becomes
  // non-temporary, and a second notification and update expiry are sent because
  // the initializing connection is registered.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 2);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kConnected);
#ifndef NINSPECT
  EXPECT_EQ(InspectBrEdrConnectionState(),
            Peer::ConnectionStateToString(Peer::ConnectionState::kConnected));
#endif  // NINSPECT

  // Registering an initializing connection when the peer is already connected
  // should assert.
  ASSERT_DEATH_IF_SUPPORTED(
      {
        Peer::InitializingConnectionToken init_token =
            peer().MutBrEdr().RegisterInitializingConnection();
      },
      ".*connected.*");
}

TEST_F(PeerTest, RegisterAndUnregisterTwoBrEdrInitializingConnections) {
  SetUpPeer(/*address=*/kAddrBrEdr, /*connectable=*/true);

  int update_expiry_count = 0;
  set_update_expiry_cb([&](const Peer&) { update_expiry_count++; });
  int notify_count = 0;
  set_notify_listeners_cb(
      [&](const Peer&, Peer::NotifyListenersChange) { notify_count++; });

  std::optional<Peer::InitializingConnectionToken> token_0 =
      peer().MutBrEdr().RegisterInitializingConnection();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  std::optional<std::string> inspect_conn_state = InspectBrEdrConnectionState();
  ASSERT_TRUE(inspect_conn_state);
  EXPECT_EQ(
      inspect_conn_state.value(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  std::optional<Peer::InitializingConnectionToken> token_1 =
      peer().MutBrEdr().RegisterInitializingConnection();
  // The second initializing connection should not update expiry or notify.
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  inspect_conn_state = InspectBrEdrConnectionState();
  ASSERT_TRUE(inspect_conn_state);
  EXPECT_EQ(
      inspect_conn_state.value(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  token_0.reset();
  EXPECT_EQ(update_expiry_count, 2);
  EXPECT_EQ(notify_count, 1);
  EXPECT_FALSE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kInitializing);
#ifndef NINSPECT
  inspect_conn_state = InspectBrEdrConnectionState();
  ASSERT_TRUE(inspect_conn_state);
  EXPECT_EQ(
      inspect_conn_state.value(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kInitializing));
#endif  // NINSPECT

  token_1.reset();
  EXPECT_EQ(update_expiry_count, 3);
  EXPECT_EQ(notify_count, 1);
  EXPECT_TRUE(peer().temporary());
  EXPECT_EQ(peer().bredr()->connection_state(),
            Peer::ConnectionState::kNotConnected);
#ifndef NINSPECT
  inspect_conn_state = InspectBrEdrConnectionState();
  ASSERT_TRUE(inspect_conn_state);
  EXPECT_EQ(
      inspect_conn_state.value(),
      Peer::ConnectionStateToString(Peer::ConnectionState::kNotConnected));
#endif  // NINSPECT
}

TEST_F(PeerTest, SettingLeAdvertisingDataOfBondedPeerDoesNotUpdateName) {
  peer().RegisterName("alice");
  sm::PairingData data;
  data.peer_ltk = kLTK;
  data.local_ltk = kLTK;
  peer().MutLe().SetBondData(data);

  const StaticByteBuffer kAdvData(0x08,  // Length
                                  0x09,  // AD type: Complete Local Name
                                  'M',
                                  'a',
                                  'l',
                                  'l',
                                  'o',
                                  'r',
                                  'y');
  peer().MutLe().SetAdvertisingData(
      /*rssi=*/0,
      kAdvData,
      pw::chrono::SystemClock::time_point(std::chrono::nanoseconds(0)));

  ASSERT_TRUE(peer().name().has_value());
  EXPECT_EQ(peer().name().value(), "alice");
}

TEST_F(PeerTest, SettingInquiryDataOfBondedPeerDoesNotUpdateName) {
  peer().RegisterName("alice");
  peer().MutBrEdr().SetBondData(kLTK);

  const StaticByteBuffer kEirData(0x08,  // Length
                                  0x09,  // AD type: Complete Local Name
                                  'M',
                                  'a',
                                  'l',
                                  'l',
                                  'o',
                                  'r',
                                  'y');
  StaticPacket<pw::bluetooth::emboss::ExtendedInquiryResultEventWriter> eirep;
  eirep.view().num_responses().Write(1);
  eirep.view().bd_addr().CopyFrom(peer().address().value().view());
  eirep.view().extended_inquiry_response().BackingStorage().CopyFrom(
      ::emboss::support::ReadOnlyContiguousBuffer(&kEirData), kEirData.size());

  peer().MutBrEdr().SetInquiryData(eirep.view());

  ASSERT_TRUE(peer().name().has_value());
  EXPECT_EQ(peer().name().value(), "alice");
}

TEST_F(PeerTest, BrEdrDataSetEirDataDoesUpdatePeerName) {
  peer().MutBrEdr();  // Initialize BrEdrData.
  ASSERT_FALSE(peer().name().has_value());

  bool listener_notified = false;
  set_notify_listeners_cb(
      [&](auto&, Peer::NotifyListenersChange) { listener_notified = true; });

  const StaticByteBuffer kEirData(0x0D,  // Length (13)
                                  0x09,  // AD type: Complete Local Name
                                  'S',
                                  'a',
                                  'p',
                                  'p',
                                  'h',
                                  'i',
                                  'r',
                                  'e',
                                  0xf0,
                                  0x9f,
                                  0x92,
                                  0x96);

  StaticPacket<pw::bluetooth::emboss::ExtendedInquiryResultEventWriter> eirep;
  eirep.view().num_responses().Write(1);
  eirep.view().bd_addr().CopyFrom(peer().address().value().view());
  eirep.view().extended_inquiry_response().BackingStorage().CopyFrom(
      ::emboss::support::ReadOnlyContiguousBuffer(&kEirData), kEirData.size());

  peer().MutBrEdr().SetInquiryData(eirep.view());

  EXPECT_TRUE(listener_notified);  // Fresh EIR data results in an update
  ASSERT_TRUE(peer().name().has_value());
  EXPECT_EQ(peer().name().value(), "Sapphire💖");
}

TEST_F(PeerTest, SetEirDataUpdatesServiceUUIDs) {
  peer().MutBrEdr();  // Initialize BrEdrData.
                      // clang-format off
  const StaticByteBuffer kEirJustServiceUuids{
      // One 16-bit UUID: AudioSink
      0x03, static_cast<uint8_t>(DataType::kIncomplete16BitServiceUuids), 0x0A, 0x11,
  };

  StaticPacket<pw::bluetooth::emboss::ExtendedInquiryResultEventWriter> eirep;
  eirep.view().num_responses().Write(1);
  eirep.view().bd_addr().CopyFrom(peer().address().value().view());
  eirep.view().extended_inquiry_response().BackingStorage().CopyFrom(
      ::emboss::support::ReadOnlyContiguousBuffer(&kEirJustServiceUuids),
      kEirJustServiceUuids.size());
  peer().MutBrEdr().SetInquiryData(eirep.view());

  EXPECT_EQ(peer().bredr()->services().size(), 1u);
  EXPECT_EQ(peer().bredr()->services().count(UUID((uint16_t)0x110A)), 1u);
}

TEST_F(PeerTest, LowEnergyStoreBondCallsCallback) {
  int cb_count = 0;
  set_store_le_bond_cb([&cb_count](const sm::PairingData& data) {
    cb_count++;
    return true;
  });

  sm::PairingData data;
  data.peer_ltk = kLTK;
  data.local_ltk = kLTK;
  EXPECT_TRUE(peer().MutLe().StoreBond(data));
  EXPECT_EQ(cb_count, 1);
}

}  // namespace
}  // namespace bt::gap