// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "connections/implementation/client_proxy.h"

#include <cstdio>
#include <string>

#include "gmock/gmock.h"
#include "protobuf-matchers/protocol-buffer-matchers.h"
#include "gtest/gtest.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/str_format.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "absl/types/span.h"
#include "connections/listeners.h"
#include "connections/strategy.h"
#include "internal/platform/byte_array.h"
#include "internal/platform/feature_flags.h"
#include "internal/platform/medium_environment.h"

namespace location {
namespace nearby {
namespace connections {
namespace {

using ::testing::MockFunction;
using ::testing::StrictMock;

constexpr FeatureFlags::Flags kTestCases[] = {
    FeatureFlags::Flags{
        .enable_cancellation_flag = true,
    },
    FeatureFlags::Flags{
        .enable_cancellation_flag = false,
    },
};

class ClientProxyTest : public ::testing::TestWithParam<FeatureFlags::Flags> {
 protected:
  struct MockDiscoveryListener {
    StrictMock<MockFunction<void(const std::string& endpoint_id,
                                 const ByteArray& endpoint_info,
                                 const std::string& service_id)>>
        endpoint_found_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id)>>
        endpoint_lost_cb;
  };
  struct MockConnectionListener {
    StrictMock<MockFunction<void(const std::string& endpoint_id,
                                 const ConnectionResponseInfo& info)>>
        initiated_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id)>> accepted_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id,
                                 const Status& status)>>
        rejected_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id)>>
        disconnected_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id,
                                 std::int32_t quality)>>
        bandwidth_changed_cb;
  };
  struct MockPayloadListener {
    StrictMock<
        MockFunction<void(const std::string& endpoint_id, Payload payload)>>
        payload_cb;
    StrictMock<MockFunction<void(const std::string& endpoint_id,
                                 const PayloadProgressInfo& info)>>
        payload_progress_cb;
  };

  struct Endpoint {
    ByteArray info;
    std::string id;
  };

  bool ShouldEnterHighVisibilityMode(
      const AdvertisingOptions& advertising_options) {
    return !advertising_options.low_power &&
           advertising_options.allowed.bluetooth;
  }

  Endpoint StartAdvertising(
      ClientProxy* client, ConnectionListener listener,
      AdvertisingOptions advertising_options = AdvertisingOptions{}) {
    if (ShouldEnterHighVisibilityMode(advertising_options)) {
      client->EnterHighVisibilityMode();
    }
    Endpoint endpoint{
        .info = ByteArray{"advertising endpoint name"},
        .id = client->GetLocalEndpointId(),
    };
    client->StartedAdvertising(service_id_, strategy_, listener,
                               absl::MakeSpan(mediums_), advertising_options);
    return endpoint;
  }

  void StopAdvertising(ClientProxy* client) { client->StoppedAdvertising(); }

  Endpoint StartDiscovery(ClientProxy* client, DiscoveryListener listener) {
    Endpoint endpoint{
        .info = ByteArray{"discovery endpoint name"},
        .id = client->GetLocalEndpointId(),
    };
    client->StartedDiscovery(service_id_, strategy_, listener,
                             absl::MakeSpan(mediums_));
    return endpoint;
  }

  void OnDiscoveryEndpointFound(ClientProxy* client, const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_.endpoint_found_cb, Call).Times(1);
    client->OnEndpointFound(service_id_, endpoint.id, endpoint.info, medium_);
  }

  void OnDiscoveryEndpointLost(ClientProxy* client, const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_.endpoint_lost_cb, Call).Times(1);
    client->OnEndpointLost(service_id_, endpoint.id);
  }

  void OnDiscoveryConnectionInitiated(ClientProxy* client,
                                      const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_connection_.initiated_cb, Call).Times(1);
    const std::string auth_token{"auth_token"};
    const ByteArray raw_auth_token{auth_token};
    const std::string connection_token{"conntokn"};
    advertising_connection_info_.remote_endpoint_info = endpoint.info;
    client->OnConnectionInitiated(
        endpoint.id, advertising_connection_info_, connection_options_,
        discovery_connection_listener_, connection_token);
    EXPECT_TRUE(client->HasPendingConnectionToEndpoint(endpoint.id));
  }

  void OnDiscoveryConnectionLocalAccepted(ClientProxy* client,
                                          const Endpoint& endpoint) {
    EXPECT_TRUE(client->HasPendingConnectionToEndpoint(endpoint.id));
    EXPECT_FALSE(client->HasLocalEndpointResponded(endpoint.id));
    client->LocalEndpointAcceptedConnection(endpoint.id, payload_listener_);
    EXPECT_TRUE(client->HasLocalEndpointResponded(endpoint.id));
    EXPECT_TRUE(client->LocalConnectionIsAccepted(endpoint.id));
  }

  void OnDiscoveryConnectionRemoteAccepted(ClientProxy* client,
                                           const Endpoint& endpoint) {
    EXPECT_TRUE(client->HasPendingConnectionToEndpoint(endpoint.id));
    EXPECT_FALSE(client->HasRemoteEndpointResponded(endpoint.id));
    client->RemoteEndpointAcceptedConnection(endpoint.id);
    EXPECT_TRUE(client->HasRemoteEndpointResponded(endpoint.id));
    EXPECT_TRUE(client->RemoteConnectionIsAccepted(endpoint.id));
  }

  void OnDiscoveryConnectionLocalRejected(ClientProxy* client,
                                          const Endpoint& endpoint) {
    EXPECT_TRUE(client->HasPendingConnectionToEndpoint(endpoint.id));
    EXPECT_FALSE(client->HasLocalEndpointResponded(endpoint.id));
    client->LocalEndpointRejectedConnection(endpoint.id);
    EXPECT_TRUE(client->HasLocalEndpointResponded(endpoint.id));
    EXPECT_FALSE(client->LocalConnectionIsAccepted(endpoint.id));
  }

  void OnDiscoveryConnectionRemoteRejected(ClientProxy* client,
                                           const Endpoint& endpoint) {
    EXPECT_TRUE(client->HasPendingConnectionToEndpoint(endpoint.id));
    EXPECT_FALSE(client->HasRemoteEndpointResponded(endpoint.id));
    client->RemoteEndpointRejectedConnection(endpoint.id);
    EXPECT_TRUE(client->HasRemoteEndpointResponded(endpoint.id));
    EXPECT_FALSE(client->RemoteConnectionIsAccepted(endpoint.id));
  }

  void OnDiscoveryConnectionAccepted(ClientProxy* client,
                                     const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_connection_.accepted_cb, Call).Times(1);
    EXPECT_TRUE(client->IsConnectionAccepted(endpoint.id));
    client->OnConnectionAccepted(endpoint.id);
  }

  void OnDiscoveryConnectionRejected(ClientProxy* client,
                                     const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_connection_.rejected_cb, Call).Times(1);
    EXPECT_TRUE(client->IsConnectionRejected(endpoint.id));
    client->OnConnectionRejected(endpoint.id, {Status::kConnectionRejected});
  }

  void OnDiscoveryBandwidthChanged(ClientProxy* client,
                                   const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_connection_.bandwidth_changed_cb, Call).Times(1);
    client->OnBandwidthChanged(endpoint.id, Medium::WIFI_LAN);
  }

  void OnDiscoveryConnectionDisconnected(ClientProxy* client,
                                         const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_connection_.disconnected_cb, Call).Times(1);
    client->OnDisconnected(endpoint.id, true);
  }

  void OnPayload(ClientProxy* client, const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_payload_.payload_cb, Call).Times(1);
    client->OnPayload(endpoint.id, Payload(payload_bytes_));
  }

  void OnPayloadProgress(ClientProxy* client, const Endpoint& endpoint) {
    EXPECT_CALL(mock_discovery_payload_.payload_progress_cb, Call).Times(1);
    client->OnPayloadProgress(endpoint.id, {});
  }

  MockDiscoveryListener mock_discovery_;
  MockConnectionListener mock_discovery_connection_;
  MockPayloadListener mock_discovery_payload_;

  proto::connections::Medium medium_{proto::connections::Medium::BLUETOOTH};
  std::vector<proto::connections::Medium> mediums_{
      proto::connections::Medium::BLUETOOTH,
  };
  Strategy strategy_{Strategy::kP2pPointToPoint};
  const std::string service_id_{"service"};
  ClientProxy client1_;
  ClientProxy client2_;
  std::string auth_token_ = "auth_token";
  ByteArray raw_auth_token_ = ByteArray(auth_token_);
  ByteArray payload_bytes_{"bytes"};
  ConnectionResponseInfo advertising_connection_info_{
      .authentication_token = auth_token_,
      .raw_authentication_token = raw_auth_token_,
      .is_incoming_connection = true,
  };
  ConnectionListener advertising_connection_listener_;
  ConnectionListener discovery_connection_listener_{
      .initiated_cb = mock_discovery_connection_.initiated_cb.AsStdFunction(),
      .accepted_cb = mock_discovery_connection_.accepted_cb.AsStdFunction(),
      .rejected_cb = mock_discovery_connection_.rejected_cb.AsStdFunction(),
      .disconnected_cb =
          mock_discovery_connection_.disconnected_cb.AsStdFunction(),
      .bandwidth_changed_cb =
          mock_discovery_connection_.bandwidth_changed_cb.AsStdFunction(),
  };
  DiscoveryListener discovery_listener_{
      .endpoint_found_cb = mock_discovery_.endpoint_found_cb.AsStdFunction(),
      .endpoint_lost_cb = mock_discovery_.endpoint_lost_cb.AsStdFunction(),
  };
  PayloadListener payload_listener_{
      .payload_cb = mock_discovery_payload_.payload_cb.AsStdFunction(),
      .payload_progress_cb =
          mock_discovery_payload_.payload_progress_cb.AsStdFunction(),
  };
  ConnectionOptions connection_options_;
  AdvertisingOptions advertising_options_;
  DiscoveryOptions discovery_options_;
};

TEST_P(ClientProxyTest, CanCancelEndpoint) {
  FeatureFlags::Flags feature_flags = GetParam();
  MediumEnvironment::Instance().SetFeatureFlags(feature_flags);

  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);

  EXPECT_FALSE(
      client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());

  client2_.CancelEndpoint(advertising_endpoint.id);

  // If FeatureFlag is disabled, Cancelled is false as no-op.
  if (!feature_flags.enable_cancellation_flag) {
    EXPECT_FALSE(
        client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());
  } else {
    // The Cancelled is always true as the default flag being returned.
    EXPECT_TRUE(
        client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());
  }
}

TEST_P(ClientProxyTest, CanCancelAllEndpoints) {
  FeatureFlags::Flags feature_flags = GetParam();
  MediumEnvironment::Instance().SetFeatureFlags(feature_flags);

  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);

  EXPECT_FALSE(
      client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());

  client2_.CancelAllEndpoints();

  // If FeatureFlag is disabled, Cancelled is false as no-op.
  if (!feature_flags.enable_cancellation_flag) {
    EXPECT_FALSE(
        client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());
  } else {
    // The Cancelled is always true as the default flag being returned.
    EXPECT_TRUE(
        client2_.GetCancellationFlag(advertising_endpoint.id)->Cancelled());
  }
}

TEST_P(ClientProxyTest, CanCancelAllEndpointsWithDifferentEndpoint) {
  FeatureFlags::Flags feature_flags = GetParam();
  MediumEnvironment::Instance().SetFeatureFlags(feature_flags);

  ConnectionListener advertising_connection_listener_2;
  ConnectionListener advertising_connection_listener_3;
  ClientProxy client3;

  StartDiscovery(&client1_, discovery_listener_);
  Endpoint advertising_endpoint_2 =
      StartAdvertising(&client2_, advertising_connection_listener_2);
  Endpoint advertising_endpoint_3 =
      StartAdvertising(&client3, advertising_connection_listener_3);
  OnDiscoveryEndpointFound(&client1_, advertising_endpoint_2);
  OnDiscoveryConnectionInitiated(&client1_, advertising_endpoint_2);
  OnDiscoveryEndpointFound(&client1_, advertising_endpoint_3);
  OnDiscoveryConnectionInitiated(&client1_, advertising_endpoint_3);

  // The CancellationFlag of endpoint_2 and endpoint_3 have been added. Default
  // Cancelled is false.
  EXPECT_FALSE(
      client1_.GetCancellationFlag(advertising_endpoint_2.id)->Cancelled());
  EXPECT_FALSE(
      client1_.GetCancellationFlag(advertising_endpoint_3.id)->Cancelled());

  client1_.CancelAllEndpoints();

  if (!feature_flags.enable_cancellation_flag) {
    // The CancellationFlag of endpoint_2 and endpoint_3 will not be removed
    // since it is not added. The default flag returned as Cancelled being true,
    // but Cancelled requested is false since the FeatureFlag is off.
    EXPECT_FALSE(
        client1_.GetCancellationFlag(advertising_endpoint_2.id)->Cancelled());
    EXPECT_FALSE(
        client1_.GetCancellationFlag(advertising_endpoint_3.id)->Cancelled());
  } else {
    // Expect the CancellationFlag of endpoint_2 and endpoint_3 has been
    // removed. The Cancelled is always true as the default flag being returned.
    EXPECT_TRUE(
        client1_.GetCancellationFlag(advertising_endpoint_2.id)->Cancelled());
    EXPECT_TRUE(
        client1_.GetCancellationFlag(advertising_endpoint_3.id)->Cancelled());
  }
}

INSTANTIATE_TEST_SUITE_P(ParametrisedClientProxyTest, ClientProxyTest,
                         ::testing::ValuesIn(kTestCases));

TEST_F(ClientProxyTest, ConstructorDestructorWorks) { SUCCEED(); }

TEST_F(ClientProxyTest, ClientIdIsUnique) {
  EXPECT_NE(client1_.GetClientId(), client2_.GetClientId());
}

TEST_F(ClientProxyTest, DumpString) {
  std::string expect = absl::StrFormat(
      "Nearby Connections State\n"
      "  Client ID: %d\n"
      "  Local Endpoint ID: %s\n"
      "  High Visibility Mode: 0\n"
      "  Is Advertising: 0\n"
      "  Advertising Service ID: \n"
      "  Is Discovering: 0\n"
      "  Discovery Service ID: \n"
      "  Connections: \n"
      "  Discovered endpoint IDs: \n",
      client1_.GetClientId(), client1_.GetLocalEndpointId());
  std::string dump = client1_.Dump();
  EXPECT_EQ(dump, expect);
}

TEST_F(ClientProxyTest, GeneratedEndpointIdIsUnique) {
  EXPECT_NE(client1_.GetLocalEndpointId(), client2_.GetLocalEndpointId());
}

TEST_F(ClientProxyTest, ResetClearsState) {
  client1_.Reset();
  EXPECT_FALSE(client1_.IsAdvertising());
  EXPECT_FALSE(client1_.IsDiscovering());
  EXPECT_TRUE(client1_.GetAdvertisingServiceId().empty());
  EXPECT_TRUE(client1_.GetDiscoveryServiceId().empty());
}

TEST_F(ClientProxyTest, StartedAdvertisingChangesStateFromIdle) {
  client1_.StartedAdvertising(service_id_, strategy_, {}, {});

  EXPECT_TRUE(client1_.IsAdvertising());
  EXPECT_FALSE(client1_.IsDiscovering());
  EXPECT_EQ(client1_.GetAdvertisingServiceId(), service_id_);
  EXPECT_TRUE(client1_.GetDiscoveryServiceId().empty());
}

TEST_F(ClientProxyTest, StartedDiscoveryChangesStateFromIdle) {
  client1_.StartedDiscovery(service_id_, strategy_, {}, {});

  EXPECT_FALSE(client1_.IsAdvertising());
  EXPECT_TRUE(client1_.IsDiscovering());
  EXPECT_TRUE(client1_.GetAdvertisingServiceId().empty());
  EXPECT_EQ(client1_.GetDiscoveryServiceId(), service_id_);
}

TEST_F(ClientProxyTest, OnEndpointFoundFiresNotificationInDiscovery) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnEndpointLostFiresNotificationInDiscovery) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryEndpointLost(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnConnectionInitiatedFiresNotificationInDiscovery) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnBandwidthChangedFiresNotificationInDiscovery) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionLocalAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionRemoteAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionAccepted(&client2_, advertising_endpoint);
  OnDiscoveryBandwidthChanged(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnDisconnectedFiresNotificationInDiscovery) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionDisconnected(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, LocalEndpointAcceptedConnectionChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionLocalAccepted(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, LocalEndpointRejectedConnectionChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionLocalRejected(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, RemoteEndpointAcceptedConnectionChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionRemoteAccepted(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, RemoteEndpointRejectedConnectionChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionRemoteRejected(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnPayloadChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionLocalAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionRemoteAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionAccepted(&client2_, advertising_endpoint);
  OnPayload(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest, OnPayloadProgressChangesState) {
  Endpoint advertising_endpoint =
      StartAdvertising(&client1_, advertising_connection_listener_);
  StartDiscovery(&client2_, discovery_listener_);
  OnDiscoveryEndpointFound(&client2_, advertising_endpoint);
  OnDiscoveryConnectionInitiated(&client2_, advertising_endpoint);
  OnDiscoveryConnectionLocalAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionRemoteAccepted(&client2_, advertising_endpoint);
  OnDiscoveryConnectionAccepted(&client2_, advertising_endpoint);
  OnPayloadProgress(&client2_, advertising_endpoint);
}

TEST_F(ClientProxyTest,
       EndpointIdCacheWhenHighVizAdvertisementAgainImmediately) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = true;

  AdvertisingOptions advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      false,  // low_power
  };

  Endpoint advertising_endpoint_1 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  StopAdvertising(&client1_);

  // Advertise immediately.
  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  EXPECT_EQ(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

TEST_F(ClientProxyTest,
       EndpointIdRotateWhenHighVizAdvertisementAgainForAWhile) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = true;

  AdvertisingOptions advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      false,  // low_power
  };

  Endpoint advertising_endpoint_1 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  StopAdvertising(&client1_);

  // Wait to expire and then advertise.
  absl::SleepFor(ClientProxy::kHighPowerAdvertisementEndpointIdCacheTimeout +
                 absl::Milliseconds(100));
  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  EXPECT_NE(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

TEST_F(ClientProxyTest,
       EndpointIdRotateWhenLowVizAdvertisementAfterHighVizAdvertisement) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = true;

  AdvertisingOptions high_viz_advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      false,  // low_power
  };
  Endpoint advertising_endpoint_1 =
      StartAdvertising(&client1_, advertising_connection_listener_,
                       high_viz_advertising_options);

  StopAdvertising(&client1_);

  AdvertisingOptions low_viz_advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      true,   // low_power
  };

  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, low_viz_advertising_options);

  EXPECT_NE(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

// Tests endpoint_id rotates when discover.
TEST_F(ClientProxyTest, EndpointIdRotateWhenStartDiscovery) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = true;

  AdvertisingOptions advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      false,  // low_power
  };

  Endpoint advertising_endpoint_1 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  StopAdvertising(&client1_);
  StartDiscovery(&client1_, discovery_listener_);

  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  EXPECT_NE(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

// Tests the low visibility mode with bluetooth disabled advertisment.
TEST_F(ClientProxyTest,
       EndpointIdRotateWhenLowVizAdvertisementWithBluetoothDisabled) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = false;

  AdvertisingOptions advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      false,  // low_power
  };

  Endpoint advertising_endpoint_1 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  StopAdvertising(&client1_);

  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  EXPECT_NE(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

// Tests the low visibility mode with low power advertisment.
TEST_F(ClientProxyTest, EndpointIdRotateWhenLowVizAdvertisementWithLowPower) {
  BooleanMediumSelector booleanMediumSelector;
  booleanMediumSelector.bluetooth = false;

  AdvertisingOptions advertising_options{
      {
          strategy_,
          booleanMediumSelector,
      },
      false,  // auto_upgrade_bandwidth
      false,  // enforce_topology_constraints
      true,   // low_power
  };
  Endpoint advertising_endpoint_1 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  StopAdvertising(&client1_);

  Endpoint advertising_endpoint_2 = StartAdvertising(
      &client1_, advertising_connection_listener_, advertising_options);

  EXPECT_NE(advertising_endpoint_1.id, advertising_endpoint_2.id);
}

}  // namespace
}  // namespace connections
}  // namespace nearby
}  // namespace location