// Copyright 2021 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/dbus/encrypted_reporting_service_provider.h"

#include <limits>
#include <memory>
#include <utility>

#include "base/functional/callback.h"
#include "base/memory/ref_counted_delete_on_sequence.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/strcat.h"
#include "base/task/bind_post_task.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/thread_pool.h"
#include "chrome/browser/policy/messaging_layer/storage_selector/storage_selector.h"
#include "chrome/browser/policy/messaging_layer/upload/event_upload_size_controller.h"
#include "chrome/browser/policy/messaging_layer/upload/file_upload_impl.h"
#include "chrome/browser/policy/messaging_layer/upload/upload_client.h"
#include "chrome/browser/policy/messaging_layer/upload/upload_provider.h"
#include "chromeos/dbus/missive/history_tracker.h"
#include "chromeos/dbus/missive/missive_client.h"
#include "components/reporting/proto/synced/interface.pb.h"
#include "components/reporting/proto/synced/status.pb.h"
#include "components/reporting/resources/resource_manager.h"
#include "components/reporting/util/status.h"
#include "components/reporting/util/statusor.h"
#include "dbus/bus.h"
#include "dbus/exported_object.h"
#include "dbus/message.h"
#include "third_party/cros_system_api/dbus/service_constants.h"

namespace ash {

namespace {

static constexpr uint64_t kDefaultMemoryAllocation =
    64u * 1024uLL * 1024uLL;  // 64 MiB by default

// UMA name for memory usage by uploads.
// The memory is logged as a `used` percent of `total`. Recorded every time we
// receive a new upload request. Expected to be well below 100%.
constexpr char kUploadMemoryUsage[] = "Browser.ERP.UploadMemoryUsagePercent";

void SendStatusAsResponse(
    std::unique_ptr<dbus::Response> response,
    dbus::ExportedObject::ResponseSender response_sender,
    ::reporting::UploadEncryptedRecordResponse response_message,
    ::reporting::StatusOr<std::list<int64_t>> result) {
  if (result.has_value()) {
    // Log cache state in `response_message`
    for (const auto& seq_id : result.value()) {
      response_message.add_cached_events_seq_ids(seq_id);
    }
  } else {
    // Build `StatusProto` in `response_message`
    result.error().SaveTo(response_message.mutable_status());
  }

  // Turn on/off the debug state flag.
  response_message.set_health_data_logging_enabled(
      ::reporting::HistoryTracker::Get()->debug_state());

  // Encode whole `response_message`
  dbus::MessageWriter writer(response.get());
  writer.AppendProtoAsArrayOfBytes(response_message);

  // Send `response`
  std::move(response_sender).Run(std::move(response));
}

}  // namespace

// EncryptedReportingServiceProvider implementation.

EncryptedReportingServiceProvider::EncryptedReportingServiceProvider(
    std::unique_ptr<::reporting::EncryptedReportingUploadProvider>
        upload_provider)
    : origin_thread_id_(base::PlatformThread::CurrentId()),
      origin_thread_runner_(base::SingleThreadTaskRunner::GetCurrentDefault()),
      memory_resource_(base::MakeRefCounted<::reporting::ResourceManager>(
          kDefaultMemoryAllocation)),
      upload_provider_(std::move(upload_provider)) {
  CHECK(upload_provider_);
}

EncryptedReportingServiceProvider::~EncryptedReportingServiceProvider() =
    default;

void EncryptedReportingServiceProvider::Start(
    scoped_refptr<dbus::ExportedObject> exported_object) {
  CHECK(OnOriginThread());
  exported_object->ExportMethod(
      chromeos::kChromeReportingServiceInterface,
      chromeos::kChromeReportingServiceUploadEncryptedRecordMethod,
      base::BindRepeating(
          &EncryptedReportingServiceProvider::RequestUploadEncryptedRecords,
          weak_ptr_factory_.GetWeakPtr()),
      base::BindOnce(&EncryptedReportingServiceProvider::OnExported,
                     weak_ptr_factory_.GetWeakPtr()));
}

void EncryptedReportingServiceProvider::OnExported(
    const std::string& interface_name,
    const std::string& method_name,
    bool success) {
  LOG_IF(ERROR, !success) << "Failed to export " << interface_name << "."
                          << method_name;
}

// static
::reporting::ReportSuccessfulUploadCallback
EncryptedReportingServiceProvider::GetReportSuccessUploadCallback() {
  chromeos::MissiveClient* const missive_client =
      chromeos::MissiveClient::Get();
  return base::BindPostTask(
      missive_client->origin_task_runner(),
      base::BindRepeating(
          [](base::WeakPtr<chromeos::MissiveClient> missive_client,
             ::reporting::SequenceInformation sequence_information,
             bool force_confirm) {
            if (missive_client) {
              missive_client->ReportSuccess(std::move(sequence_information),
                                            force_confirm);
            }
          },
          missive_client->GetWeakPtr()));
}

// static
::reporting::EncryptionKeyAttachedCallback
EncryptedReportingServiceProvider::GetEncryptionKeyAttachedCallback() {
  chromeos::MissiveClient* const missive_client =
      chromeos::MissiveClient::Get();
  return base::BindPostTask(
      missive_client->origin_task_runner(),
      base::BindRepeating(
          [](base::WeakPtr<chromeos::MissiveClient> missive_client,
             ::reporting::SignedEncryptionInfo signed_encryption_info) {
            if (missive_client) {
              missive_client->UpdateEncryptionKey(
                  std::move(signed_encryption_info));
            }
          },
          missive_client->GetWeakPtr()));
}

// static
::reporting::UpdateConfigInMissiveCallback
EncryptedReportingServiceProvider::GetUpdateConfigInMissiveCallback() {
  chromeos::MissiveClient* const missive_client =
      chromeos::MissiveClient::Get();
  return base::BindPostTask(
      missive_client->origin_task_runner(),
      base::BindRepeating(
          [](base::WeakPtr<chromeos::MissiveClient> missive_client,
             ::reporting::ListOfBlockedDestinations destinations) {
            if (missive_client) {
              missive_client->UpdateConfigInMissive(std::move(destinations));
            }
          },
          missive_client->GetWeakPtr()));
}

void EncryptedReportingServiceProvider::RequestUploadEncryptedRecords(
    dbus::MethodCall* method_call,
    dbus::ExportedObject::ResponseSender response_sender) {
  CHECK(OnOriginThread());
  auto response = dbus::Response::FromMethodCall(method_call);
  ::reporting::UploadEncryptedRecordResponse response_message;

  chromeos::MissiveClient* const missive_client =
      chromeos::MissiveClient::Get();
  if (!missive_client) {
    ::reporting::Status status{::reporting::error::FAILED_PRECONDITION,
                               "No Missive client available"};
    LOG(ERROR) << status;
    SendStatusAsResponse(std::move(response), std::move(response_sender),
                         std::move(response_message), base::unexpected(status));
    return;
  }

  if (!missive_client->has_valid_api_key()) {
    response_message.set_disable(true);  // Signal `missived` to disable itself.
    ::reporting::Status status{
        ::reporting::error::FAILED_PRECONDITION,
        "Cannot communicate with server, unsupported API Key"};
    LOG(ERROR) << status;
    SendStatusAsResponse(std::move(response), std::move(response_sender),
                         std::move(response_message), base::unexpected(status));
    return;
  }

  dbus::MessageReader reader(method_call);
  const char* serialized_request_buf = nullptr;
  size_t serialized_request_buf_size = 0;
  if (!reader.PopArrayOfBytes(
          reinterpret_cast<const uint8_t**>(&serialized_request_buf),
          &serialized_request_buf_size)) {
    ::reporting::Status status{
        ::reporting::error::INVALID_ARGUMENT,
        "Error reading UploadEncryptedRecordRequest as array of bytes"};
    LOG(ERROR) << "Unable to process UploadEncryptedRecordRequest. status: "
               << status;
    SendStatusAsResponse(std::move(response), std::move(response_sender),
                         std::move(response_message), base::unexpected(status));
    return;
  }

  ::reporting::ScopedReservation scoped_reservation(serialized_request_buf_size,
                                                    memory_resource_);

  // Update UMA on actual memory usage.
  base::UmaHistogramPercentage(
      kUploadMemoryUsage,
      static_cast<int>(memory_resource_->GetUsed() * 100uL /
                       memory_resource_->GetTotal()));  // Never zero.

  if (!scoped_reservation.reserved()) {
    ::reporting::Status status{::reporting::error::RESOURCE_EXHAUSTED,
                               "UploadEncryptedRecordRequest has exhausted "
                               "assigned memory pool in Chrome"};
    LOG(ERROR) << "Unable to process UploadEncryptedRecordRequest. status: "
               << status;
    SendStatusAsResponse(std::move(response), std::move(response_sender),
                         std::move(response_message), base::unexpected(status));
    return;
  }

  ::reporting::UploadEncryptedRecordRequest request;
  if (!request.ParseFromArray(serialized_request_buf,
                              serialized_request_buf_size)) {
    ::reporting::Status status{
        ::reporting::error::INVALID_ARGUMENT,
        "Failed to parse UploadEncryptedRecordRequest from array of "
        "bytes."};
    LOG(ERROR) << "Unable to process UploadEncryptedRecordRequest. status: "
               << status;
    SendStatusAsResponse(std::move(response), std::move(response_sender),
                         std::move(response_message), base::unexpected(status));
    return;
  }

  // Missive should always send the remaining storage capacity and new
  // events rate. If not, probably an outdated version of missive is
  // running. In this case, we ignore the effect of remaining storage
  // capacity/new events rate and give it the max/min possible value.
  const auto remaining_storage_capacity =
      request.has_remaining_storage_capacity()
          ? request.remaining_storage_capacity()
          : std::numeric_limits<uint64_t>::max();
  const auto new_events_rate =
      request.has_new_events_rate() ? request.new_events_rate() : 1U;
  // Move events from |request| into a separate vector |records|, using more
  // or less the same amount of memory that has been reserved above.
  auto records{::reporting::EventUploadSizeController::BuildEncryptedRecords(
      std::move(*request.mutable_encrypted_record()),
      ::reporting::EventUploadSizeController(
          network_condition_service_, new_events_rate,
          remaining_storage_capacity,
          ::reporting::FileUploadDelegate::kMaxUploadBufferSize))};

  // Accept health data if present.
  if (request.has_health_data()) {
    ::reporting::HistoryTracker::Get()->set_data(
        std::move(request.health_data()), base::DoNothing());
  }

  upload_provider_->RequestUploadEncryptedRecords(
      request.need_encryption_keys(), std::move(records),
      std::move(scoped_reservation),
      base::BindPostTask(
          origin_thread_runner_,
          base::BindOnce(&SendStatusAsResponse, std::move(response),
                         std::move(response_sender),
                         std::move(response_message))));
}

bool EncryptedReportingServiceProvider::OnOriginThread() const {
  return base::PlatformThread::CurrentId() == origin_thread_id_;
}

// static
std::unique_ptr<::reporting::EncryptedReportingUploadProvider>
EncryptedReportingServiceProvider::GetDefaultUploadProvider() {
  return std::make_unique<::reporting::EncryptedReportingUploadProvider>(
      GetReportSuccessUploadCallback(), GetEncryptionKeyAttachedCallback(),
      GetUpdateConfigInMissiveCallback());
}
}  // namespace ash