// Copyright 2022 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/wallpaper/wallpaper_drivefs_delegate_impl.h"

#include <map>

#include "ash/public/cpp/image_downloader.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.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 "base/unguessable_token.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chromeos/ash/components/drivefs/drivefs_host.h"
#include "chromeos/ash/components/drivefs/mojom/drivefs.mojom.h"
#include "components/account_id/account_id.h"
#include "components/drive/file_errors.h"
#include "components/drive/file_system_core_util.h"
#include "google_apis/common/api_error_codes.h"
#include "net/http/http_request_headers.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "ui/gfx/image/image_skia.h"
#include "url/gurl.h"

namespace ash {

namespace {

constexpr net::NetworkTrafficAnnotationTag kDriveFsDownloadWallpaperTag =
    net::DefineNetworkTrafficAnnotation("wallpaper_drivefs_delegate", R"(
      semantics {
        sender: "Wallpaper DriveFs"
        description: "Download wallpaper images from Google Drive."
        trigger:
          "Triggered when another device owned by the same user has uploaded a "
          "wallpaper image to Google Drive to sync to this device."
        data: "Readonly OAuth token for Google Drive"
        destination: GOOGLE_OWNED_SERVICE
      }
      policy {
        cookies_allowed: NO
        setting:
          "Users can disable downloading wallpapers from drive by toggling "
          "Disconnect Google Drive account in chrome://os-settings/files, or "
          "by turning off wallpaper sync in chrome://os-settings/osSync"
        chrome_policy: {
          DriveDisabled {
            DriveDisabled: true
          }
          SyncDisabled {
            SyncDisabled: true
          }
          WallpaperImage {
            WallpaperImage: "png or jpg encoded image data"
          }
        }
      }
    )");

constexpr char kDriveFsWallpaperDirName[] = "Chromebook Wallpaper";
constexpr char kDriveFsWallpaperFileName[] = "wallpaper.jpg";
constexpr char kDriveFsTempWallpaperFileName[] = "wallpaper-tmp.jpg";

// Gets a pointer to `DriveIntegrationService` to interact with DriveFS.  If
// DriveFS is not enabled or mounted for this `account_id`, responds with
// `nullptr`. Caller must check null safety carefully, as DriveFS can crash,
// disconnect, or unmount itself and this function will start returning
// `nullptr`.
// If the pointer to `DriveIntegrationService` is held for a long duration, the
// owner must implement `DriveIntegrationService::Observer` to avoid
// use-after-free.
drive::DriveIntegrationService* GetDriveIntegrationService(
    const AccountId& account_id) {
  Profile* profile = ProfileHelper::Get()->GetProfileByAccountId(account_id);
  if (!profile) {
    VLOG(1) << "No profile for account_id";
    return nullptr;
  }

  drive::DriveIntegrationService* drive_integration_service =
      drive::util::GetIntegrationServiceByProfile(profile);

  if (!drive_integration_service || !drive_integration_service->is_enabled() ||
      !drive_integration_service->IsMounted()) {
    return nullptr;
  }

  return drive_integration_service;
}

// Gets a relative path from the DriveFS mount point to the wallpaper file.
base::FilePath GetWallpaperRelativePath() {
  return base::FilePath(drive::util::kDriveMyDriveRootDirName)
      .Append(kDriveFsWallpaperDirName)
      .Append(kDriveFsWallpaperFileName);
}

base::Time GetModificationTimeFromDriveMetadata(
    drive::FileError error,
    drivefs::mojom::FileMetadataPtr metadata) {
  if (error != drive::FILE_ERROR_OK || !metadata) {
    VLOG(1) << "Unable to get metadata for DriveFs wallpaper file. Error: "
            << error;
    return base::Time();
  }
  return metadata->modification_time;
}

// Copies file `source` from outside DriveFS, to `destination` inside DriveFS.
// `destination` must be the path to the DriveFS wallpaper file. Copies the
// file to a temporary file first, and then swaps it to the final file path, in
// order to avoid partial writes corrupting the wallpaper image saved to
// DriveFS. Must be run on a blocking task runner.
bool CopyFileToDriveFsBlocking(const base::FilePath& source,
                               const base::FilePath& destination) {
  DCHECK_EQ(destination.BaseName().value(), kDriveFsWallpaperFileName);
  const base::FilePath directory = destination.DirName();
  DCHECK_EQ(directory.BaseName().value(), kDriveFsWallpaperDirName);
  if (!base::DirectoryExists(directory) && !base::CreateDirectory(directory)) {
    DVLOG(1) << "Failed to create DriveFS '" << kDriveFsWallpaperDirName
             << "' directory";
    return false;
  }

  base::FilePath temp_file_path =
      directory.Append(base::UnguessableToken::Create().ToString().append(
          kDriveFsTempWallpaperFileName));

  if (!base::CopyFile(source, temp_file_path)) {
    DVLOG(1) << "Failed to copy wallpaper file to DriveFs";
    base::DeleteFile(temp_file_path);
    return false;
  }

  base::File::Error error;
  if (!base::ReplaceFile(temp_file_path, destination, &error)) {
    DVLOG(1) << "Failed to move temp wallpaper file with error '" << error
             << "'";
    base::DeleteFile(temp_file_path);
    return false;
  }
  return true;
}

}  // namespace

WallpaperChangeWaiter::WallpaperChangeWaiter(
    const AccountId& account_id,
    base::OnceCallback<void(bool success)> callback)
    : account_id_(account_id),
      path_to_watch_(base::FilePath(base::FilePath::kSeparators)
                         .Append(GetWallpaperRelativePath())),
      callback_(std::move(callback)) {
  DCHECK(callback_);
  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    std::move(callback_).Run(/*success=*/false);
    return;
  }

  Observe(drive_integration_service->GetDriveFsHost());
}

WallpaperChangeWaiter::~WallpaperChangeWaiter() {
  if (callback_) {
    std::move(callback_).Run(/*success=*/false);
  }
}

void WallpaperChangeWaiter::OnUnmounted() {
  if (callback_) {
    std::move(callback_).Run(/*success=*/false);
  }
}

void WallpaperChangeWaiter::OnError(const drivefs::mojom::DriveError& error) {
  if (error.path == path_to_watch_ && callback_) {
    LOG(WARNING) << "DriveFS wallpaper error: " << error.type;
    std::move(callback_).Run(/*success=*/false);
  }
}

void WallpaperChangeWaiter::OnFilesChanged(
    const std::vector<drivefs::mojom::FileChange>& changes) {
  for (const auto& change : changes) {
    if (change.path == path_to_watch_ && callback_) {
      std::move(callback_).Run(/*success=*/true);
      return;
    }
  }
}

WallpaperDriveFsDelegateImpl::WallpaperDriveFsDelegateImpl()
    : blocking_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})) {}

WallpaperDriveFsDelegateImpl::~WallpaperDriveFsDelegateImpl() = default;

base::FilePath WallpaperDriveFsDelegateImpl::GetWallpaperPath(
    const AccountId& account_id) {
  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    VLOG(1)
        << "Cannot get DriveFS Wallpaper path because DriveFS is unavailable";
    return base::FilePath();
  }
  auto mount_path = drive_integration_service->GetMountPointPath();
  DCHECK(!mount_path.empty());
  return mount_path.Append(GetWallpaperRelativePath());
}

void WallpaperDriveFsDelegateImpl::SaveWallpaper(
    const AccountId& account_id,
    const base::FilePath& source,
    base::OnceCallback<void(bool)> callback) {
  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    DVLOG(1)
        << "Not saving wallpaper to DriveFS because DriveFS is unavailable";
    std::move(callback).Run(/*success=*/false);
    return;
  }
  blocking_task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&CopyFileToDriveFsBlocking, source,
                     GetWallpaperPath(account_id)),
      std::move(callback));
}

void WallpaperDriveFsDelegateImpl::WaitForWallpaperChange(
    const AccountId& account_id,
    WaitForWallpaperChangeCallback callback) {
  // Remove any old `WallpaperChangeWaiter` and create a new one. The old one
  // will run any pending callbacks on deletion.
  wallpaper_change_waiters_.erase(account_id);
  wallpaper_change_waiters_.try_emplace(
      account_id, account_id,
      base::BindOnce(&WallpaperDriveFsDelegateImpl::OnDriveFsWallpaperChanged,
                     weak_ptr_factory_.GetWeakPtr(), account_id,
                     std::move(callback)));
}

void WallpaperDriveFsDelegateImpl::GetWallpaperModificationTime(
    const AccountId& account_id,
    base::OnceCallback<void(base::Time modification_time)> callback) {
  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    std::move(callback).Run(base::Time());
    return;
  }

  drive_integration_service->GetMetadata(
      GetWallpaperPath(account_id),
      base::BindOnce(&GetModificationTimeFromDriveMetadata)
          .Then(std::move(callback)));
}

void WallpaperDriveFsDelegateImpl::DownloadAndDecodeWallpaper(
    const AccountId& account_id,
    ImageDownloader::DownloadCallback callback) {
  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    VLOG(1) << "Skip downloading custom wallpaper because DriveFS is not "
               "available.";
    std::move(callback).Run(gfx::ImageSkia());
    return;
  }

  drive_integration_service->GetMetadata(
      GetWallpaperPath(account_id),
      base::BindOnce(&WallpaperDriveFsDelegateImpl::OnGetDownloadUrlMetadata,
                     weak_ptr_factory_.GetWeakPtr(), account_id,
                     std::move(callback)));
}

void WallpaperDriveFsDelegateImpl::OnGetDownloadUrlMetadata(
    const AccountId& account_id,
    ImageDownloader::DownloadCallback callback,
    drive::FileError error,
    drivefs::mojom::FileMetadataPtr metadata) {
  if (error != drive::FileError::FILE_ERROR_OK || !metadata ||
      metadata->download_url.empty()) {
    VLOG(1) << "Unable to get download url for DriveFS wallpaper";
    std::move(callback).Run(gfx::ImageSkia());
    return;
  }

  auto* drive_integration_service = GetDriveIntegrationService(account_id);
  if (!drive_integration_service) {
    VLOG(1) << "DriveFS no longer mounted, cannot fetch authentication token";
    std::move(callback).Run(gfx::ImageSkia());
    return;
  }

  drive_integration_service->GetReadOnlyAuthenticationToken(base::BindOnce(
      &WallpaperDriveFsDelegateImpl::OnGetDownloadUrlAndAuthentication,
      weak_ptr_factory_.GetWeakPtr(), account_id, std::move(callback),
      GURL(metadata->download_url)));
}

void WallpaperDriveFsDelegateImpl::OnGetDownloadUrlAndAuthentication(
    const AccountId& account_id,
    ImageDownloader::DownloadCallback callback,
    const GURL& download_url,
    google_apis::ApiErrorCode error_code,
    const std::string& authentication_token) {
  if (error_code != google_apis::HTTP_SUCCESS || authentication_token.empty()) {
    VLOG(1) << "Unable to fetch authentication token for DriveFS with error "
            << error_code;
    std::move(callback).Run(gfx::ImageSkia());
    return;
  }
  net::HttpRequestHeaders headers;
  headers.SetHeader(net::HttpRequestHeaders::kAuthorization,
                    "Bearer " + authentication_token);
  ImageDownloader::Get()->Download(download_url, kDriveFsDownloadWallpaperTag,
                                   account_id, std::move(headers),
                                   std::move(callback));
}

void WallpaperDriveFsDelegateImpl::OnDriveFsWallpaperChanged(
    const AccountId& account_id,
    WaitForWallpaperChangeCallback callback,
    bool success) {
  std::move(callback).Run(success);
  wallpaper_change_waiters_.erase(account_id);
}

}  // namespace ash