// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/values.h"
#include "chromeos/ash/components/dbus/shill/shill_clients.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/network/enterprise_managed_metadata_store.h"
#include "chromeos/ash/components/network/hotspot_allowed_flag_handler.h"
#include "chromeos/ash/components/network/hotspot_capabilities_provider.h"
#include "chromeos/ash/components/network/hotspot_controller.h"
#include "chromeos/ash/components/network/hotspot_state_handler.h"
#include "chromeos/ash/components/network/metrics/hotspot_feature_usage_metrics.h"
#include "chromeos/ash/components/network/metrics/hotspot_metrics_helper.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/network_state_test_helper.h"
#include "chromeos/ash/services/hotspot_config/public/mojom/cros_hotspot_config.mojom.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace ash {

namespace {

const char kCellularServicePath[] = "/service/cellular0";
const char kCellularServiceGuid[] = "cellular_guid0";
const char kCellularServiceName[] = "cellular_name0";
const char kHotspotFeatureUsage[] = "ChromeOS.FeatureUsage.Hotspot";

class TestObserver : public HotspotController::Observer {
 public:
  TestObserver() = default;
  ~TestObserver() override = default;

  // HotspotStateHandler::Observer:
  void OnHotspotTurnedOn() override { hotspot_turned_on_count_++; }
  void OnHotspotTurnedOff(
      hotspot_config::mojom::DisableReason disable_reason) override {
    last_disable_reason_ = disable_reason;
    hotspot_turned_off_count_++;
  }

  size_t hotspot_turned_on_count() { return hotspot_turned_on_count_; }

  size_t hotspot_turned_off_count() { return hotspot_turned_off_count_; }

  std::optional<hotspot_config::mojom::DisableReason> last_disable_reason() {
    return last_disable_reason_;
  }

 private:
  size_t hotspot_turned_on_count_ = 0u;
  size_t hotspot_turned_off_count_ = 0u;
  std::optional<hotspot_config::mojom::DisableReason> last_disable_reason_ =
      std::nullopt;
};

}  // namespace

class HotspotControllerConcurrencyApiTest : public ::testing::Test {
 public:
  // This struct is used to simplify checking the metrics associated with the
  // tests below.
  struct ExpectedHistogramState {
    size_t success_initial_count = 0u;
    size_t success_retry_count = 0u;
    size_t inhibit_failed_initial_count = 0u;
    size_t inhibit_failed_retry_count = 0u;
    size_t hermes_install_failed_initial_count = 0u;
    size_t hermes_install_failed_retry_count = 0u;
    size_t smds_scan_profile_total_count = 0u;
    size_t smds_scan_profile_sum = 0u;
    size_t no_available_profiles_via_smdp_count = 0u;
    size_t no_available_profiles_via_smds_count = 0u;
    size_t install_method_via_smdp_count = 0u;
    size_t install_method_via_smds_count = 0u;
    size_t scan_duration_other_success_count = 0u;
    size_t scan_duration_other_failure_count = 0u;
    size_t scan_duration_android_success_count = 0u;
    size_t scan_duration_android_failure_count = 0u;
    size_t scan_duration_gsma_success_count = 0u;
    size_t scan_duration_gsma_failure_count = 0u;
  };

  HotspotControllerConcurrencyApiTest() {
    feature_list_.InitAndEnableFeature(features::kWifiConcurrency);
  }
  ~HotspotControllerConcurrencyApiTest() override = default;

  void SetUp() override {
    enterprise_managed_metadata_store_ =
        std::make_unique<EnterpriseManagedMetadataStore>();
    hotspot_capabilities_provider_ =
        std::make_unique<HotspotCapabilitiesProvider>();
    hotspot_allowed_flag_handler_ =
        std::make_unique<HotspotAllowedFlagHandler>();
    hotspot_capabilities_provider_->Init(
        network_state_test_helper_.network_state_handler(),
        hotspot_allowed_flag_handler_.get());
    hotspot_feature_usage_metrics_ =
        std::make_unique<HotspotFeatureUsageMetrics>();
    hotspot_feature_usage_metrics_->Init(
        enterprise_managed_metadata_store_.get(),
        hotspot_capabilities_provider_.get());
    hotspot_state_handler_ = std::make_unique<HotspotStateHandler>();
    hotspot_state_handler_->Init();
    hotspot_controller_ = std::make_unique<HotspotController>();
    hotspot_controller_->Init(
        hotspot_capabilities_provider_.get(),
        hotspot_feature_usage_metrics_.get(), hotspot_state_handler_.get(),
        network_state_test_helper_.technology_state_controller());
    hotspot_controller_->AddObserver(&observer_);
    SetReadinessCheckResultReady();
  }

  void TearDown() override {
    hotspot_controller_->RemoveObserver(&observer_);
    hotspot_controller_.reset();
    hotspot_feature_usage_metrics_.reset();
    hotspot_capabilities_provider_.reset();
    hotspot_allowed_flag_handler_.reset();
    hotspot_state_handler_.reset();
    enterprise_managed_metadata_store_.reset();
  }

  void SetHotspotAllowed() {
    hotspot_capabilities_provider_->SetHotspotAllowStatus(
        hotspot_config::mojom::HotspotAllowStatus::kAllowed);
  }

  void SetHotspotStateInShill(const std::string& state) {
    auto status_dict =
        base::Value::Dict().Set(shill::kTetheringStatusStateProperty, state);
    network_state_test_helper_.manager_test()->SetManagerProperty(
        shill::kTetheringStatusProperty, base::Value(std::move(status_dict)));
    base::RunLoop().RunUntilIdle();
  }

  void SetReadinessCheckResultReady() {
    network_state_test_helper_.manager_test()
        ->SetSimulateCheckTetheringReadinessResult(
            FakeShillSimulatedResult::kSuccess,
            shill::kTetheringReadinessReady);
    base::RunLoop().RunUntilIdle();
  }

  void AddActiveCellularService() {
    ShillServiceClient::TestInterface* service_test =
        network_state_test_helper_.service_test();
    service_test->AddService(kCellularServicePath, kCellularServiceGuid,
                             kCellularServiceName, shill::kTypeCellular,
                             shill::kStateOnline, /*visible=*/true);
  }

  hotspot_config::mojom::HotspotControlResult EnableHotspot() {
    base::RunLoop run_loop;
    hotspot_config::mojom::HotspotControlResult return_result;
    hotspot_controller_->EnableHotspot(base::BindLambdaForTesting(
        [&](hotspot_config::mojom::HotspotControlResult result) {
          return_result = result;
          run_loop.Quit();
        }));
    run_loop.Run();
    FlushMojoCalls();
    return return_result;
  }

  hotspot_config::mojom::HotspotControlResult DisableHotspot() {
    base::RunLoop run_loop;
    hotspot_config::mojom::HotspotControlResult return_result;
    hotspot_controller_->DisableHotspot(
        base::BindLambdaForTesting(
            [&](hotspot_config::mojom::HotspotControlResult result) {
              return_result = result;
              run_loop.Quit();
            }),
        hotspot_config::mojom::DisableReason::kUserInitiated);
    run_loop.Run();
    FlushMojoCalls();
    return return_result;
  }

  bool PrepareEnableWifi() {
    base::RunLoop run_loop;
    bool prepare_success;
    hotspot_controller_->PrepareEnableWifi(
        base::BindLambdaForTesting([&](bool result) {
          prepare_success = result;
          run_loop.Quit();
        }));
    run_loop.Run();
    FlushMojoCalls();
    return prepare_success;
  }

  void SetPolicyAllowHotspot(bool allow_hotspot) {
    base::RunLoop run_loop;
    hotspot_controller_->SetPolicyAllowHotspot(allow_hotspot);
    run_loop.RunUntilIdle();
  }

  void EnableAndAbortHotspot() {
    base::RunLoop run_loop;
    hotspot_config::mojom::HotspotControlResult enable_result =
        hotspot_config::mojom::HotspotControlResult::kUnknownFailure;
    hotspot_config::mojom::HotspotControlResult disable_result =
        hotspot_config::mojom::HotspotControlResult::kUnknownFailure;
    hotspot_controller_->EnableHotspot(base::BindLambdaForTesting(
        [&](hotspot_config::mojom::HotspotControlResult result) {
          enable_result = result;
          run_loop.Quit();
        }));
    hotspot_controller_->DisableHotspot(
        base::BindLambdaForTesting(
            [&](hotspot_config::mojom::HotspotControlResult result) {
              disable_result = result;
              run_loop.Quit();
            }),
        hotspot_config::mojom::DisableReason::kUserInitiated);
    run_loop.Run();
    FlushMojoCalls();

    EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kAborted,
              enable_result);
    EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kAlreadyFulfilled,
              disable_result);
  }

  void FlushMojoCalls() { base::RunLoop().RunUntilIdle(); }

 protected:
  base::test::TaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  base::HistogramTester histogram_tester_;
  base::test::ScopedFeatureList feature_list_;
  std::unique_ptr<EnterpriseManagedMetadataStore>
      enterprise_managed_metadata_store_;
  std::unique_ptr<HotspotController> hotspot_controller_;
  std::unique_ptr<HotspotCapabilitiesProvider> hotspot_capabilities_provider_;
  std::unique_ptr<HotspotAllowedFlagHandler> hotspot_allowed_flag_handler_;
  std::unique_ptr<HotspotFeatureUsageMetrics> hotspot_feature_usage_metrics_;
  std::unique_ptr<HotspotStateHandler> hotspot_state_handler_;
  NetworkStateTestHelper network_state_test_helper_{
      /*use_default_devices_and_services=*/false};
  TestObserver observer_;
};

TEST_F(HotspotControllerConcurrencyApiTest, EnableTetheringSuccess) {
  SetHotspotAllowed();
  AddActiveCellularService();
  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess, shill::kTetheringEnableResultSuccess);
  base::RunLoop().RunUntilIdle();

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::kReady, 1);

  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kSuccess,
            EnableHotspot());
  // Verifies that Wifi technology will be turned off.
  EXPECT_EQ(
      NetworkStateHandler::TECHNOLOGY_AVAILABLE,
      network_state_test_helper_.network_state_handler()->GetTechnologyState(
          NetworkTypePattern::WiFi()));

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableLatency, 1);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 2);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::kReady, 2);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::kSuccess, 1);
  histogram_tester_.ExpectBucketCount(
      kHotspotFeatureUsage,
      static_cast<int>(
          feature_usage::FeatureUsageMetrics::Event::kUsedWithSuccess),
      1);
}

TEST_F(HotspotControllerConcurrencyApiTest, AbortEnableTethering) {
  SetHotspotAllowed();
  AddActiveCellularService();
  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess, shill::kTetheringEnableResultSuccess);
  base::RunLoop().RunUntilIdle();

  EnableAndAbortHotspot();

  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::kAborted, 1);
}

TEST_F(HotspotControllerConcurrencyApiTest,
       ShillOperationFailureWhileAborting) {
  SetHotspotAllowed();
  AddActiveCellularService();
  base::RunLoop().RunUntilIdle();

  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess,
      shill::kTetheringEnableResultNetworkSetupFailure);
  base::RunLoop().RunUntilIdle();

  EnableAndAbortHotspot();

  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::kAborted, 1);
}

TEST_F(HotspotControllerConcurrencyApiTest,
       EnableTetheringReadinessCheckFailure) {
  // Setup the hotspot capabilities so that the initial hotspot allowance
  // status is allowed.
  SetHotspotAllowed();
  AddActiveCellularService();
  base::RunLoop().RunUntilIdle();

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::kReady, 1);

  // Simulate check tethering readiness operation fail.
  network_state_test_helper_.manager_test()
      ->SetSimulateCheckTetheringReadinessResult(
          FakeShillSimulatedResult::kFailure,
          /*readiness_status=*/std::string());
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kReadinessCheckFailed,
            EnableHotspot());
  EXPECT_EQ(
      hotspot_config::mojom::HotspotAllowStatus::kDisallowedReadinessCheckFail,
      hotspot_capabilities_provider_->GetHotspotCapabilities().allow_status);

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableLatency, 1);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 2);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::
          kShillOperationFailed,
      1);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::
          kReadinessCheckFailure,
      1);
}

TEST_F(HotspotControllerConcurrencyApiTest,
       EnableTetheringNetworkSetupFailure) {
  // Setup the hotspot capabilities so that the initial hotspot allowance
  // status is allowed.
  SetHotspotAllowed();
  AddActiveCellularService();
  base::RunLoop().RunUntilIdle();

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::kReady, 1);

  // Simulate enable tethering operation fail with
  // kTetheringEnableResultNetworkSetupFailure error.
  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess,
      shill::kTetheringEnableResultNetworkSetupFailure);
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kNetworkSetupFailure,
            EnableHotspot());
  // Verifies that Wifi technology will still be on if enable hotspot failed.
  EXPECT_EQ(
      NetworkStateHandler::TECHNOLOGY_ENABLED,
      network_state_test_helper_.network_state_handler()->GetTechnologyState(
          NetworkTypePattern::WiFi()));

  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableLatency, 1);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram, 2);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotCheckReadinessResultHistogram,
      HotspotMetricsHelper::HotspotMetricsCheckReadinessResult::kReady, 2);
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotEnableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::
          kNetworkSetupFailure,
      1);
  histogram_tester_.ExpectBucketCount(
      kHotspotFeatureUsage,
      static_cast<int>(
          feature_usage::FeatureUsageMetrics::Event::kUsedWithFailure),
      1);
}

TEST_F(HotspotControllerConcurrencyApiTest, DisableTetheringSuccess) {
  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kAlreadyFulfilled,
            DisableHotspot());
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotDisableResultHistogram, 1);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotDisableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::kAlreadyFulfilled,
      1);

  SetHotspotStateInShill(shill::kTetheringStateActive);
  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess, shill::kTetheringEnableResultSuccess);
  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kSuccess,
            DisableHotspot());
  histogram_tester_.ExpectTotalCount(
      HotspotMetricsHelper::kHotspotDisableResultHistogram, 2);
  histogram_tester_.ExpectBucketCount(
      HotspotMetricsHelper::kHotspotDisableResultHistogram,
      HotspotMetricsHelper::HotspotMetricsSetEnabledResult::kSuccess, 1);
}

TEST_F(HotspotControllerConcurrencyApiTest, SetPolicyAllowHotspot) {
  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess, shill::kTetheringEnableResultSuccess);
  SetHotspotStateInShill(shill::kTetheringStateActive);
  SetHotspotAllowed();
  SetPolicyAllowHotspot(/*allow_hotspot=*/false);
  EXPECT_EQ(1u, observer_.hotspot_turned_off_count());
  EXPECT_EQ(hotspot_config::mojom::DisableReason::kProhibitedByPolicy,
            observer_.last_disable_reason());
  EXPECT_EQ(
      hotspot_config::mojom::HotspotAllowStatus::kDisallowedByPolicy,
      hotspot_capabilities_provider_->GetHotspotCapabilities().allow_status);

  SetPolicyAllowHotspot(/*allow_hotspot=*/true);
  EXPECT_EQ(
      hotspot_config::mojom::HotspotAllowStatus::kAllowed,
      hotspot_capabilities_provider_->GetHotspotCapabilities().allow_status);
}

TEST_F(HotspotControllerConcurrencyApiTest, RestoreWiFiStatus) {
  SetHotspotAllowed();
  AddActiveCellularService();
  // Verify Wifi is on before turning on hotspot.
  EXPECT_EQ(
      NetworkStateHandler::TECHNOLOGY_ENABLED,
      network_state_test_helper_.network_state_handler()->GetTechnologyState(
          NetworkTypePattern::WiFi()));

  network_state_test_helper_.manager_test()->SetSimulateTetheringEnableResult(
      FakeShillSimulatedResult::kSuccess, shill::kTetheringEnableResultSuccess);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(hotspot_config::mojom::HotspotControlResult::kSuccess,
            EnableHotspot());

  // Verifies that Wifi will be turned off.
  EXPECT_EQ(
      NetworkStateHandler::TECHNOLOGY_AVAILABLE,
      network_state_test_helper_.network_state_handler()->GetTechnologyState(
          NetworkTypePattern::WiFi()));

  SetHotspotStateInShill(shill::kTetheringStateIdle);
  base::RunLoop().RunUntilIdle();
  // Verifies that Wifi will be turned back on.
  EXPECT_EQ(
      NetworkStateHandler::TECHNOLOGY_ENABLED,
      network_state_test_helper_.network_state_handler()->GetTechnologyState(
          NetworkTypePattern::WiFi()));
}

}  // namespace ash