// 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/phonehub/camera_roll_download_manager_impl.h"

#include <optional>
#include <utility>

#include "ash/public/cpp/holding_space/holding_space_progress.h"
#include "base/check.h"
#include "base/containers/flat_map.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/safe_base_name.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/numerics/clamped_math.h"
#include "base/numerics/safe_conversions.h"
#include "base/system/sys_info.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "base/time/time.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_keyed_service.h"
#include "chromeos/ash/components/multidevice/logging/logging.h"
#include "chromeos/ash/components/phonehub/camera_roll_download_manager.h"
#include "chromeos/ash/components/phonehub/proto/phonehub_api.pb.h"
#include "chromeos/ash/services/secure_channel/public/mojom/secure_channel_types.mojom.h"

namespace ash::phonehub {

namespace {

const size_t kBytesPerKilobyte = 1024;

scoped_refptr<base::SequencedTaskRunner> CreateTaskRunner() {
  return base::ThreadPool::CreateSequencedTaskRunner(
      {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
}

bool HasEnoughDiskSpace(const base::FilePath& root_path,
                        const proto::CameraRollItemMetadata& item_metadata) {
  DCHECK(item_metadata.file_size_bytes() >= 0);
  return base::SysInfo::AmountOfFreeDiskSpace(root_path) >=
         item_metadata.file_size_bytes();
}

std::optional<secure_channel::mojom::PayloadFilesPtr> DoCreatePayloadFiles(
    const base::FilePath& file_path) {
  if (base::PathExists(file_path)) {
    // Perhaps a file was created at the same path for a different payload after
    // we checkedfor its existence.
    return std::nullopt;
  }

  base::File output_file =
      base::File(file_path, base::File::Flags::FLAG_CREATE_ALWAYS |
                                base::File::Flags::FLAG_WRITE);
  base::File input_file = base::File(
      file_path, base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ);
  return secure_channel::mojom::PayloadFiles::New(std::move(input_file),
                                                  std::move(output_file));
}

}  // namespace

CameraRollDownloadManagerImpl::DownloadItem::DownloadItem(
    int64_t payload_id,
    const base::FilePath& file_path,
    int64_t file_size_bytes,
    const std::string& holding_space_item_id)
    : payload_id(payload_id),
      file_path(file_path),
      file_size_bytes(file_size_bytes),
      holding_space_item_id(holding_space_item_id) {}

CameraRollDownloadManagerImpl::DownloadItem::~DownloadItem() = default;

CameraRollDownloadManagerImpl::CameraRollDownloadManagerImpl(
    const base::FilePath& download_path,
    ash::HoldingSpaceKeyedService* holding_space_keyed_service)
    : download_path_(download_path),
      holding_space_keyed_service_(holding_space_keyed_service),
      task_runner_(CreateTaskRunner()) {}

CameraRollDownloadManagerImpl::~CameraRollDownloadManagerImpl() = default;

void CameraRollDownloadManagerImpl::CreatePayloadFiles(
    int64_t payload_id,
    const proto::CameraRollItemMetadata& item_metadata,
    CreatePayloadFilesCallback payload_files_callback) {
  std::optional<base::SafeBaseName> base_name(
      base::SafeBaseName::Create(item_metadata.file_name()));
  if (!base_name || base_name->path().value() != item_metadata.file_name()) {
    PA_LOG(WARNING) << "Camera roll item file name "
                    << item_metadata.file_name() << " is not a valid base name";
    return std::move(payload_files_callback)
        .Run(CreatePayloadFilesResult::kInvalidFileName, std::nullopt);
  }

  if (pending_downloads_.contains(payload_id)) {
    PA_LOG(WARNING) << "Payload " << payload_id
                    << " is already being downloaded";
    return std::move(payload_files_callback)
        .Run(CreatePayloadFilesResult::kPayloadAlreadyExists, std::nullopt);
  }

  task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&HasEnoughDiskSpace, download_path_, item_metadata),
      base::BindOnce(&CameraRollDownloadManagerImpl::OnDiskSpaceCheckComplete,
                     weak_ptr_factory_.GetWeakPtr(), base_name.value(),
                     payload_id, item_metadata.file_size_bytes(),
                     std::move(payload_files_callback)));
}

void CameraRollDownloadManagerImpl::OnDiskSpaceCheckComplete(
    const base::SafeBaseName& base_name,
    int64_t payload_id,
    int64_t file_size_bytes,
    CreatePayloadFilesCallback payload_files_callback,
    bool has_enough_disk_space) {
  if (!has_enough_disk_space) {
    std::move(payload_files_callback)
        .Run(CreatePayloadFilesResult::kInsufficientDiskSpace, std::nullopt);
    return;
  }

  task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&base::GetUniquePath,
                     download_path_.Append(base_name.path())),
      base::BindOnce(&CameraRollDownloadManagerImpl::OnUniquePathFetched,
                     weak_ptr_factory_.GetWeakPtr(), payload_id,
                     file_size_bytes, std::move(payload_files_callback)));
}

void CameraRollDownloadManagerImpl::OnUniquePathFetched(
    int64_t payload_id,
    int64_t file_size_bytes,
    CreatePayloadFilesCallback payload_files_callback,
    const base::FilePath& unique_path) {
  task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE, base::BindOnce(&DoCreatePayloadFiles, unique_path),
      base::BindOnce(&CameraRollDownloadManagerImpl::OnPayloadFilesCreated,
                     weak_ptr_factory_.GetWeakPtr(), payload_id, unique_path,
                     file_size_bytes, std::move(payload_files_callback)));
}

void CameraRollDownloadManagerImpl::OnPayloadFilesCreated(
    int64_t payload_id,
    const base::FilePath& file_path,
    int64_t file_size_bytes,
    CreatePayloadFilesCallback payload_files_callback,
    std::optional<secure_channel::mojom::PayloadFilesPtr> payload_files) {
  if (!payload_files) {
    PA_LOG(WARNING) << "Failed to create files for payload " << payload_id
                    << ": the requested file path already exists.";
    return std::move(payload_files_callback)
        .Run(CreatePayloadFilesResult::kNotUniqueFilePath, std::nullopt);
  }

  const std::string& holding_space_item_id =
      holding_space_keyed_service_->AddItemOfType(
          HoldingSpaceItem::Type::kPhoneHubCameraRoll, file_path,
          ash::HoldingSpaceProgress(/*current_bytes=*/0,
                                    /*total_bytes=*/file_size_bytes));
  if (holding_space_item_id.empty()) {
    // This can happen if a file was created at the same path for a previous
    // payload but then got deleted before that payload is fully downloaded.
    PA_LOG(WARNING) << "Failed to add payload " << payload_id
                    << " to holding space. It's likely that an item with the "
                       "same file path already exists.";
    return std::move(payload_files_callback)
        .Run(CreatePayloadFilesResult::kNotUniqueFilePath, std::nullopt);
  }

  pending_downloads_.emplace(
      payload_id, DownloadItem(payload_id, file_path, file_size_bytes,
                               holding_space_item_id));

  std::move(payload_files_callback)
      .Run(CreatePayloadFilesResult::kSuccess, std::move(payload_files));
}

void CameraRollDownloadManagerImpl::UpdateDownloadProgress(
    secure_channel::mojom::FileTransferUpdatePtr update) {
  auto it = pending_downloads_.find(update->payload_id);
  if (it == pending_downloads_.end()) {
    PA_LOG(ERROR) << "Received unexpected FileTransferUpdate for payload "
                  << update->payload_id;
    return;
  }

  const DownloadItem& download_item = it->second;
  const std::string holding_space_item_id = download_item.holding_space_item_id;

  switch (update->status) {
    case secure_channel::mojom::FileTransferStatus::kInProgress:
      holding_space_keyed_service_->UpdateItem(holding_space_item_id)
          ->SetProgress(ash::HoldingSpaceProgress(update->bytes_transferred,
                                                  update->total_bytes,
                                                  /*complete=*/false));
      return;
    case secure_channel::mojom::FileTransferStatus::kFailure:
    case secure_channel::mojom::FileTransferStatus::kCanceled:
      // Delete files created for failed and canceled items, in addition to
      // removing the DownloadItem objects.
      holding_space_keyed_service_->RemoveItem(holding_space_item_id);
      DeleteFile(update->payload_id);
      return;
    case secure_channel::mojom::FileTransferStatus::kSuccess:
      holding_space_keyed_service_
          ->UpdateItem(download_item.holding_space_item_id)
          ->SetProgress(ash::HoldingSpaceProgress(update->bytes_transferred,
                                                  update->total_bytes,
                                                  /*complete=*/true))
          .SetInvalidateImage(true);
      base::UmaHistogramCounts100000(
          "PhoneHub.CameraRoll.DownloadItem.TransferRate",
          CalculateItemTransferRate(download_item));
      pending_downloads_.erase(it);
  }
}

int CameraRollDownloadManagerImpl::CalculateItemTransferRate(
    const DownloadItem& download_item) const {
  base::TimeDelta total_download_time =
      base::TimeTicks::Now() - download_item.start_timestamp;
  base::ClampedNumeric bytes_per_second = base::ClampDiv(
      download_item.file_size_bytes, total_download_time.InSecondsF());
  return base::saturated_cast<int>(
      base::ClampDiv(bytes_per_second, kBytesPerKilobyte));
}

void CameraRollDownloadManagerImpl::DeleteFile(int64_t payload_id) {
  auto it = pending_downloads_.find(payload_id);
  if (it == pending_downloads_.end()) {
    return;
  }

  task_runner_->PostTask(
      FROM_HERE, base::BindOnce(
                     [](const base::FilePath& file_path, int64_t payload_id) {
                       if (!base::DeleteFile(file_path)) {
                         PA_LOG(WARNING) << "Failed to delete file for payload "
                                         << payload_id;
                       }
                     },
                     it->second.file_path, payload_id));
  pending_downloads_.erase(it);
}

}  // namespace ash::phonehub