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

#include "chrome/browser/ash/bluetooth/debug_logs_manager.h"

#include "ash/constants/ash_features.h"
#include "base/feature_list.h"
#include "base/logging.h"
#include "base/task/single_thread_task_runner.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/dbus/bluetooth_debug_manager_client.h"
#include "device/bluetooth/dbus/bluez_dbus_manager.h"
#include "device/bluetooth/floss/floss_dbus_client.h"
#include "device/bluetooth/floss/floss_dbus_manager.h"
#include "device/bluetooth/floss/floss_features.h"
#include "device/bluetooth/floss/floss_logging_client.h"
#include "google_apis/gaia/gaia_auth_util.h"

namespace ash {

namespace bluetooth {

namespace {
const char kVerboseLoggingEnablePrefName[] = "bluetooth.verboseLogging.enable";

const uint8_t kVerboseDisabledLevel = 0;
const uint8_t kVerboseBasicLevel = 1;

const int kDbusRetryCount = 10;
constexpr base::TimeDelta kDbusRetryInterval = base::Seconds(3);
}  // namespace

DebugLogsManager::DebugLogsManager(const std::string& primary_user_email,
                                   PrefService* pref_service)
    : primary_user_email_(primary_user_email), pref_service_(pref_service) {
  // For Googlers, set the default preference of Bluetooth verbose logs to true.
  if (AreDebugLogsSupported() &&
      !pref_service->HasPrefPath(kVerboseLoggingEnablePrefName)) {
    ChangeDebugLogsState(true);
  }

  SetVerboseLogsEnable(GetDebugLogsState() ==
                       DebugLogsState::kSupportedAndEnabled);

  SetBluetoothQualityReport(
      /*enable=*/features::IsBluetoothQualityReportEnabled(),
      /*num_completed_attempts=*/0);

  // Grab the Bluetooth adapter instance so we can register observers.
  device::BluetoothAdapterFactory::Get()->GetAdapter(
      base::BindOnce(&DebugLogsManager::OnBluetoothAdapterAvailable,
                     weak_ptr_factory_.GetWeakPtr()));
}

DebugLogsManager::~DebugLogsManager() {
  if (adapter_) {
    adapter_->RemoveObserver(this);
    adapter_.reset();
  }

  SetVerboseLogsEnable(false);

  // Disable Bluetooth Quality Report if it is enabled on login.
  if (features::IsBluetoothQualityReportEnabled())
    SetBluetoothQualityReport(/*enable=*/false,
                              /*num_completed_attempts=*/0);
}

// static
void DebugLogsManager::RegisterPrefs(PrefRegistrySimple* registry) {
  registry->RegisterBooleanPref(kVerboseLoggingEnablePrefName,
                                /*default_value=*/false);
}

DebugLogsManager::DebugLogsState DebugLogsManager::GetDebugLogsState() const {
  if (!AreDebugLogsSupported())
    return DebugLogsState::kNotSupported;

  return pref_service_->GetBoolean(kVerboseLoggingEnablePrefName)
             ? DebugLogsState::kSupportedAndEnabled
             : DebugLogsState::kSupportedButDisabled;
}

mojo::PendingRemote<mojom::DebugLogsChangeHandler>
DebugLogsManager::GenerateRemote() {
  mojo::PendingRemote<mojom::DebugLogsChangeHandler> remote;
  receivers_.Add(this, remote.InitWithNewPipeAndPassReceiver());
  return remote;
}

void DebugLogsManager::ChangeDebugLogsState(bool should_debug_logs_be_enabled) {
  DCHECK_NE(GetDebugLogsState(), DebugLogsState::kNotSupported);

  pref_service_->SetBoolean(kVerboseLoggingEnablePrefName,
                            should_debug_logs_be_enabled);
}

bool DebugLogsManager::AreDebugLogsSupported() const {
  if (!base::FeatureList::IsEnabled(features::kShowBluetoothDebugLogToggle))
    return false;

  return gaia::IsGoogleInternalAccountEmail(primary_user_email_);
}

void DebugLogsManager::SetVerboseLogsEnable(bool enable) {
  debug_logs_enabled_ = enable;
  SendDBusVerboseLogsMessage(enable, /*num_completed_attempts=*/0);
}

void DebugLogsManager::SendDBusVerboseLogsMessage(bool enable,
                                                  int num_completed_attempts) {
  uint8_t level = enable ? kVerboseBasicLevel : kVerboseDisabledLevel;
  VLOG(1) << (enable ? "Enabling" : "Disabling") << " bluetooth verbose logs";

  if (floss::features::IsFlossEnabled()) {
    if (adapter_ && adapter_->IsPowered()) {
      floss::FlossDBusManager::Get()->GetLoggingClient()->SetDebugLogging(
          base::BindOnce(&DebugLogsManager::OnFlossSetDebugLogging,
                         weak_ptr_factory_.GetWeakPtr(), enable,
                         num_completed_attempts),
          enable);
    }
  } else {
    bluez::BluezDBusManager::Get()
        ->GetBluetoothDebugManagerClient()
        ->SetLogLevels(
            /*bluez_level=*/level, /*kernel_level=*/0,
            base::BindOnce(&DebugLogsManager::OnVerboseLogsEnableSuccess,
                           weak_ptr_factory_.GetWeakPtr(), enable),
            base::BindOnce(&DebugLogsManager::OnVerboseLogsEnableError,
                           weak_ptr_factory_.GetWeakPtr(), enable,
                           num_completed_attempts));
  }
}

void DebugLogsManager::OnFlossSetDebugLogging(
    const bool enable,
    const int num_completed_attempts,
    floss::DBusResult<floss::Void> result) {
  if (result.has_value()) {
    OnVerboseLogsEnableSuccess(enable);
  } else {
    auto error = result.error();
    OnVerboseLogsEnableError(enable, num_completed_attempts, error.name,
                             error.message);
  }
}

void DebugLogsManager::OnVerboseLogsEnableSuccess(const bool enable) {
  VLOG(1) << "Bluetooth verbose logs successfully "
          << (enable ? "enabled" : "disabled");
}

void DebugLogsManager::OnVerboseLogsEnableError(
    const bool enable,
    const int num_completed_attempts,
    const std::string& error_name,
    const std::string& error_message) {
  bool should_retry = (num_completed_attempts < kDbusRetryCount);

  LOG(ERROR) << "Setting bluetooth verbose logs failed: error: " << error_name
             << " - " << error_message << " "
             << (should_retry ? "Retrying." : "Giving up.");

  if (!should_retry)
    return;

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
      FROM_HERE,
      base::BindOnce(&DebugLogsManager::SendDBusVerboseLogsMessage,
                     weak_ptr_factory_.GetWeakPtr(), enable,
                     num_completed_attempts + 1),
      kDbusRetryInterval);
}

void DebugLogsManager::SetBluetoothQualityReport(bool enable,
                                                 int num_completed_attempts) {
  VLOG(1) << (enable ? "Enabling" : "Disabling") << " Bluetooth Quality Report";

  if (floss::features::IsFlossEnabled()) {
    VLOG(1) << "Floss does not yet support Bluetooth Quality Report.";
    return;
  }

  bluez::BluezDBusManager::Get()
      ->GetBluetoothDebugManagerClient()
      ->SetBluetoothQualityReport(
          enable,
          base::BindOnce(&DebugLogsManager::OnSetBluetoothQualityReportSuccess,
                         weak_ptr_factory_.GetWeakPtr(), enable),
          base::BindOnce(&DebugLogsManager::OnSetBluetoothQualityReportError,
                         weak_ptr_factory_.GetWeakPtr(), enable,
                         num_completed_attempts));
}

void DebugLogsManager::OnSetBluetoothQualityReportSuccess(bool enable) {
  VLOG(1) << "Bluetooth Quality Report successfully "
          << (enable ? "enabled" : "disabled");
}

void DebugLogsManager::OnSetBluetoothQualityReportError(
    const bool enable,
    const int num_completed_attempts,
    const std::string& error_name,
    const std::string& error_message) {
  bool should_retry = (num_completed_attempts < kDbusRetryCount);

  LOG(ERROR) << "Setting Bluetooth Quality Report failed: error: " << error_name
             << " - " << error_message << " "
             << (should_retry ? "Retrying." : "Giving up.");

  if (!should_retry)
    return;

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
      FROM_HERE,
      base::BindOnce(&DebugLogsManager::SetBluetoothQualityReport,
                     weak_ptr_factory_.GetWeakPtr(), enable,
                     num_completed_attempts + 1),
      kDbusRetryInterval);
}

void DebugLogsManager::OnBluetoothAdapterAvailable(
    scoped_refptr<device::BluetoothAdapter> adapter) {
  adapter_ = std::move(adapter);
  adapter_->AddObserver(this);

  // Bluez does not dynamically set log level (it is persistent).
  if (!floss::features::IsFlossEnabled()) {
    return;
  }

  // We only need to send enable call if BT is powered on and we want to enable
  // debug logs. We don't need to do anything if it's powered off.
  if (debug_logs_enabled_ && adapter_ && adapter_->IsPowered()) {
    SendDBusVerboseLogsMessage(debug_logs_enabled_,
                               /*num_completed_attempts=*/0);
  }
}

void DebugLogsManager::AdapterPoweredChanged(device::BluetoothAdapter* adapter,
                                             bool powered) {
  // Bluez does not dynamically set log level (it is persistent).
  if (!floss::features::IsFlossEnabled()) {
    return;
  }

  // We only need to send enable call when powering on and we want to enable
  // debug logs. We don't need to turn it off on power on.
  if (powered && debug_logs_enabled_) {
    SendDBusVerboseLogsMessage(debug_logs_enabled_,
                               /*num_completed_attempts=*/0);
  }
}

}  // namespace bluetooth

}  // namespace ash