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

#include "chromeos/ash/components/report/report_controller.h"

#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "base/time/default_clock.h"
#include "base/time/time.h"
#include "chromeos/ash/components/dbus/private_computing/private_computing_client.h"
#include "chromeos/ash/components/dbus/private_computing/private_computing_service.pb.h"
#include "chromeos/ash/components/dbus/session_manager/session_manager_client.h"
#include "chromeos/ash/components/dbus/system_clock/system_clock_sync_observation.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/report/device_metrics/actives/one_day_impl.h"
#include "chromeos/ash/components/report/device_metrics/actives/twenty_eight_day_impl.h"
#include "chromeos/ash/components/report/device_metrics/churn/cohort_impl.h"
#include "chromeos/ash/components/report/device_metrics/churn/observation_impl.h"
#include "chromeos/ash/components/report/device_metrics/use_case/use_case.h"
#include "chromeos/ash/components/report/prefs/fresnel_pref_names.h"
#include "chromeos/ash/components/report/utils/pref_utils.h"
#include "chromeos/ash/components/report/utils/time_utils.h"
#include "chromeos/ash/components/system/statistics_provider.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/version_info/channel.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"

namespace psm_rlwe = private_membership::rlwe;

namespace ash::report {

namespace {

ReportController* g_ash_report_controller = nullptr;

// Amount of time to wait before triggering repeating timer.
constexpr base::TimeDelta kTimeToRepeat = base::Hours(1);

// Maximum time to wait for time sync before not reporting device as active
// in current attempt.
// This corresponds to at least seven TCP retransmissions attempts to
// the remote server used to update the system clock.
constexpr base::TimeDelta kSystemClockSyncWaitTimeout = base::Seconds(45);

// Create helper methods for lambda functions.
base::OnceClosure CreateSavePreservedFileCallback(
    PrefService* local_state,
    base::WeakPtr<ReportController> controller_weak_ptr) {
  return base::BindOnce(
      [](PrefService* local_state,
         base::WeakPtr<ReportController> controller_weak_ptr) {
        PrivateComputingClient::Get()->SaveLastPingDatesStatus(
            utils::CreatePreservedFileContents(local_state),
            base::BindOnce(
                &ReportController::OnSaveLocalStateToPreservedFileComplete,
                controller_weak_ptr));
      },
      local_state, controller_weak_ptr);
}

base::OnceClosure CreateReportObservationCallback(
    base::WeakPtr<device_metrics::ObservationImpl> observation_weak_ptr,
    base::OnceCallback<void()> save_preserved_file_cb) {
  return base::BindOnce(&device_metrics::ObservationImpl::Run,
                        observation_weak_ptr,
                        std::move(save_preserved_file_cb));
}

base::OnceClosure CreateReportCohortCallback(
    base::WeakPtr<device_metrics::CohortImpl> cohort_weak_ptr,
    base::OnceCallback<void()> report_observation_cb) {
  return base::BindOnce(&device_metrics::CohortImpl::Run, cohort_weak_ptr,
                        std::move(report_observation_cb));
}

base::OnceClosure CreateReport28DaCallback(
    base::WeakPtr<device_metrics::TwentyEightDayImpl> twenty_eight_day_weak_ptr,
    base::OnceCallback<void()> report_cohort_cb) {
  return base::BindOnce(&device_metrics::TwentyEightDayImpl::Run,
                        twenty_eight_day_weak_ptr, std::move(report_cohort_cb));
}

// Record boolean indicating the preserved file has been written successfully.
void RecordPreservedFileWritten(bool is_written) {
  base::UmaHistogramBoolean("Ash.Report.PreservedFileWritten", is_written);
}

// Record boolean for whether the device is classified as for testing.
void RecordIsTestDevice(bool is_test) {
  base::UmaHistogramBoolean("Ash.Report.IsTestDevice", is_test);
}

// Record boolean for whether the psm stable secret key is read and parsed
// successfully from the VPD file that is loaded to machine statistics.
void RecordIsPsmSecretSet(bool is_set) {
  base::UmaHistogramBoolean("Ash.Report.IsPsmSecretSet", is_set);
}

// Record boolean for if the system clock has been synced successfully or not.
void RecordIsSystemClockSynced(bool is_synced) {
  base::UmaHistogramBoolean("Ash.Report.IsSystemClockSynced", is_synced);
}

}  // namespace

ReportController* ReportController::Get() {
  return g_ash_report_controller;
}

// static
void ReportController::RegisterPrefs(PrefRegistrySimple* registry) {
  const base::Time unix_epoch = base::Time::UnixEpoch();
  registry->RegisterTimePref(
      prefs::kDeviceActiveLastKnown1DayActivePingTimestamp, unix_epoch);
  registry->RegisterTimePref(
      prefs::kDeviceActiveLastKnown28DayActivePingTimestamp, unix_epoch);
  registry->RegisterTimePref(
      prefs::kDeviceActiveChurnCohortMonthlyPingTimestamp, unix_epoch);
  registry->RegisterTimePref(
      prefs::kDeviceActiveChurnObservationMonthlyPingTimestamp, unix_epoch);
  registry->RegisterIntegerPref(prefs::kDeviceActiveLastKnownChurnActiveStatus,
                                0);
  registry->RegisterBooleanPref(
      prefs::kDeviceActiveLastKnownIsActiveCurrentPeriodMinus0, false);
  registry->RegisterBooleanPref(
      prefs::kDeviceActiveLastKnownIsActiveCurrentPeriodMinus1, false);
  registry->RegisterBooleanPref(
      prefs::kDeviceActiveLastKnownIsActiveCurrentPeriodMinus2, false);

  registry->RegisterDictionaryPref(prefs::kDeviceActive28DayActivePingCache);
}

ReportController::ReportController(
    const device_metrics::ChromeDeviceMetadataParameters& chrome_device_params,
    PrefService* local_state,
    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
    std::unique_ptr<device_metrics::PsmClientManager> psm_client_manager)
    : chrome_device_params_(chrome_device_params),
      local_state_(local_state),
      url_loader_factory_(url_loader_factory),
      report_timer_(std::make_unique<base::RepeatingTimer>()),
      network_state_handler_(NetworkHandler::Get()->network_state_handler()),
      statistics_provider_(system::StatisticsProvider::GetInstance()),
      clock_(base::DefaultClock::GetInstance()),
      psm_client_manager_(std::move(psm_client_manager)) {
  DCHECK(local_state);
  DCHECK(psm_client_manager_.get());
  DCHECK(!g_ash_report_controller);

  g_ash_report_controller = this;

  // Halt if device is a testimage/unknown channel.
  if (chrome_device_params.chrome_channel == version_info::Channel::UNKNOWN) {
    LOG(ERROR) << "Halt - Client should enter device active reporting logic. "
               << "Unknown and test image channels should not be counted as "
               << "legitimate device counts.";
    return;
  }

  // Wrap with callback from |psm_device_active_secret_| retrieval using
  // |SessionManagerClient| DBus.
  SessionManagerClient::Get()->GetPsmDeviceActiveSecret(
      base::BindOnce(&report::ReportController::OnPsmDeviceActiveSecretFetched,
                     weak_factory_.GetWeakPtr()));
}

ReportController::~ReportController() {
  DCHECK_EQ(this, g_ash_report_controller);
  g_ash_report_controller = nullptr;

  // Reset all dependency unique_ptr objects of this class that are not needed.
  report_timer_.reset();
  system_clock_sync_observation_.reset();

  // Reset all reporting use cases.
  one_day_impl_.reset();
  twenty_eight_day_impl_.reset();
  cohort_impl_.reset();
  observation_impl_.reset();

  // Reset parameters that is passed to reporting use cases.
  use_case_params_.reset();
}

void ReportController::DefaultNetworkChanged(const NetworkState* network) {
  bool was_connected = network_connected_;
  network_connected_ = network && network->IsOnline();

  if (network_connected_ == was_connected) {
    return;
  }

  if (network_connected_) {
    OnNetworkOnline();
  } else {
    OnNetworkOffline();
  }
}

void ReportController::OnShuttingDown() {
  network_state_handler_observer_.Reset();
}

void ReportController::OnPsmDeviceActiveSecretFetched(
    const std::string& psm_device_active_secret) {
  // In order for the device actives to be reported, the psm device active
  // secret must be retrieved successfully.
  if (psm_device_active_secret.empty()) {
    LOG(ERROR) << "PSM device secret is empty and could not be fetched.";
    RecordIsPsmSecretSet(false);
    return;
  }

  RecordIsPsmSecretSet(true);
  high_entropy_seed_ = psm_device_active_secret;

  // Continue when machine statistics are loaded, to avoid blocking.
  statistics_provider_->ScheduleOnMachineStatisticsLoaded(
      base::BindOnce(&report::ReportController::OnMachineStatisticsLoaded,
                     weak_factory_.GetWeakPtr()));
}

void ReportController::OnMachineStatisticsLoaded() {
  // Block virtual machines and debug builds (dev mode enabled).
  if (statistics_provider_->IsRunningOnVm() ||
      statistics_provider_->IsCrosDebugMode()) {
    LOG(ERROR) << "Terminate - device is running in VM or with cros_debug mode "
                  "enabled.";
    LOG(ERROR) << "VM = " << statistics_provider_->IsRunningOnVm()
               << " and DEBUG = " << statistics_provider_->IsCrosDebugMode();
    RecordIsTestDevice(true);
    return;
  }

  RecordIsTestDevice(false);

  // Send DBus method to that reads preserved files for missing local state
  // prefs.
  PrivateComputingClient::Get()->GetLastPingDatesStatus(
      base::BindOnce(&ReportController::OnPreservedFileReadComplete,
                     weak_factory_.GetWeakPtr()));
}

void ReportController::OnPreservedFileReadComplete(
    private_computing::GetStatusResponse response) {
  if (response.has_error_message()) {
    LOG(ERROR) << "Failed to read preserved file. "
               << "Error from DBus: " << response.error_message();

    OnReadyToReport();
    return;
  }

  utils::RestoreLocalStateWithPreservedFile(local_state_, response);
  OnReadyToReport();
}

void ReportController::OnSaveLocalStateToPreservedFileComplete(
    private_computing::SaveStatusResponse response) {
  bool write_success = true;
  if (response.has_error_message()) {
    write_success = false;
    LOG(ERROR) << "Failed to write to preserved file. "
               << "Error from DBus: " << response.error_message();
  }
  RecordPreservedFileWritten(write_success);

  // Device is done reporting after writing to preserved file.
  is_device_reporting_ = false;

  // Reset all reporting use cases.
  one_day_impl_.reset();
  twenty_eight_day_impl_.reset();
  cohort_impl_.reset();
  observation_impl_.reset();

  // Reset parameters that is passed to reporting use cases.
  use_case_params_.reset();
}

bool ReportController::IsDeviceReportingForTesting() const {
  return is_device_reporting_;
}

void ReportController::OnReadyToReport() {
  // Retry reporting metrics every 1 hour.
  report_timer_->Start(FROM_HERE, kTimeToRepeat, this,
                       &ReportController::ReportingTriggeredByTimer);

  // Retry reporting metrics if network comes online.
  // DefaultNetworkChanged method is called every time the
  // device network properties change.
  network_state_handler_observer_.Observe(network_state_handler_.get());

  DefaultNetworkChanged(network_state_handler_->DefaultNetwork());
}

void ReportController::ReportingTriggeredByTimer() {
  // Return early if the device is not connected to the network
  // or if it is already in the middle of reporting.
  if (!network_connected_ || is_device_reporting_) {
    LOG(ERROR) << "Timer triggered reporting failed. "
               << "Network_connected = " << network_connected_
               << ". Is device reporting = " << is_device_reporting_ << ".";
    return;
  }

  OnNetworkOnline();
}

void ReportController::OnNetworkOnline() {
  // Async wait for the system clock to synchronize on network connection.
  system_clock_sync_observation_ =
      SystemClockSyncObservation::WaitForSystemClockSync(
          SystemClockClient::Get(), kSystemClockSyncWaitTimeout,
          base::BindOnce(&ReportController::OnSystemClockSyncResult,
                         weak_factory_.GetWeakPtr()));
}

void ReportController::OnNetworkOffline() {
  // TODO: Evaluate if we should cancel callbacks here.
}

void ReportController::OnSystemClockSyncResult(bool system_clock_synchronized) {
  RecordIsSystemClockSynced(system_clock_synchronized);

  if (!system_clock_synchronized) {
    LOG(ERROR) << "System clock failed to be synchronized.";
    return;
  }

  StartReport();
}

void ReportController::StartReport() {
  DCHECK(local_state_);
  DCHECK(psm_client_manager_.get());

  // Get new adjusted timestamp from GMT to Pacific Time.
  active_ts_ = utils::ConvertGmtToPt(clock_);

  // Create instances of use cases and parameters.
  use_case_params_ = std::make_unique<device_metrics::UseCaseParameters>(
      active_ts_, chrome_device_params_, url_loader_factory_,
      high_entropy_seed_, local_state_, psm_client_manager_.get());
  one_day_impl_ =
      std::make_unique<device_metrics::OneDayImpl>(use_case_params_.get());
  twenty_eight_day_impl_ = std::make_unique<device_metrics::TwentyEightDayImpl>(
      use_case_params_.get());
  cohort_impl_ =
      std::make_unique<device_metrics::CohortImpl>(use_case_params_.get());
  observation_impl_ =
      std::make_unique<device_metrics::ObservationImpl>(use_case_params_.get());

  // Create callbacks to report use cases in a specific order, and also a
  // callback that updates the preserved file using the latest local state.
  // Note that the order of the use case callbacks is important.
  // Contact chromeos-data-eng@ before making changes here.
  base::OnceClosure save_preserved_file_cb =
      CreateSavePreservedFileCallback(local_state_, weak_factory_.GetWeakPtr());
  base::OnceClosure report_observation_cb = CreateReportObservationCallback(
      observation_impl_->GetWeakPtr(), std::move(save_preserved_file_cb));
  base::OnceClosure report_cohort_cb = CreateReportCohortCallback(
      cohort_impl_->GetWeakPtr(), std::move(report_observation_cb));
  base::OnceClosure report_28da_cb = CreateReport28DaCallback(
      twenty_eight_day_impl_->GetWeakPtr(), std::move(report_cohort_cb));

  // Trigger sequential execution of callbacks by running first use case.
  is_device_reporting_ = true;

  one_day_impl_->Run(std::move(report_28da_cb));
}

}  // namespace ash::report