// Copyright 2020 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/ui/ash/thumbnail_loader.h"

#include <algorithm>
#include <utility>

#include "ash/public/cpp/image_downloader.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/json/values_util.h"
#include "base/memory/raw_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "base/values.h"
#include "chrome/browser/ash/file_manager/app_id.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/extensions/api/messaging/native_message_port.h"
#include "chrome/browser/image_decoder/image_decoder.h"
#include "chrome/browser/profiles/profile.h"
#include "extensions/browser/api/messaging/channel_endpoint.h"
#include "extensions/browser/api/messaging/message_service.h"
#include "extensions/browser/api/messaging/native_message_host.h"
#include "extensions/common/api/messaging/channel_type.h"
#include "extensions/common/api/messaging/messaging_endpoint.h"
#include "extensions/common/api/messaging/port_id.h"
#include "extensions/common/api/messaging/serialization_format.h"
#include "extensions/common/extension.h"
#include "net/base/data_url.h"
#include "net/base/mime_util.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "services/data_decoder/public/cpp/data_decoder.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "storage/browser/file_system/file_system_context.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/re2/src/re2/re2.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/image/image_skia.h"
#include "url/gurl.h"

namespace ash {

namespace {

// The native host name that will identify the thumbnail loader to the image
// loader extension.
constexpr char kNativeMessageHostName[] = "com.google.ash_thumbnail_loader";

// Returns whether the given `file_path` is supported by the `ThumbnailLoader`.
bool IsSupported(const base::FilePath& file_path) {
  constexpr std::array<std::pair<const char*, const char*>, 24>
      kFileMatchPatterns = {{
          // Document types ----------------------------------------------------
          {
              /*extension=*/"(?i)\\.pdf$",
              /*mime_type=*/"(?i)application\\/pdf",
          },
          // Image types -------------------------------------------------------
          {
              /*extension=*/"(?i)\\.jpe?g$",
              /*mime_type=*/"(?i)image\\/jpeg",
          },
          {
              /*extension=*/"(?i)\\.bmp$",
              /*mime_type=*/"(?i)image\\/bmp",
          },
          {
              /*extension=*/"(?i)\\.gif$",
              /*mime_type=*/"(?i)image\\/gif",
          },
          {
              /*extension=*/"(?i)\\.ico$",
              /*mime_type=*/"(?i)image\\/x\\-icon",
          },
          {
              /*extension=*/"(?i)\\.png$",
              /*mime_type=*/"(?i)image\\/png",
          },
          {
              /*extension=*/"(?i)\\.webp$",
              /*mime_type=*/"(?i)image\\/webp",
          },
          {
              /*extension=*/"(?i)\\.tiff?$",
              /*mime_type=*/"(?i)image\\/tiff",
          },
          {
              /*extension=*/"(?i)\\.svg$",
              /*mime_type=*/"(?i)image\\/svg\\+xml",
          },
          // Raw types ---------------------------------------------------------
          {
              /*extension=*/"(?i)\\.arw$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.cr2$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.dng$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.nef$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.nrw$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.orf$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.raf$",
              /*mime_type=*/nullptr,
          },
          {
              /*extension=*/"(?i)\\.rw2$",
              /*mime_type=*/nullptr,
          },
          // Video types -------------------------------------------------------
          {
              /*extension=*/"(?i)\\.3gpp?$",
              /*mime_type=*/"(?i)video\\/3gpp",
          },
          {
              /*extension=*/"(?i)\\.avi$",
              /*mime_type=*/"(?i)video\\/x\\-msvideo",
          },
          {
              /*extension=*/"(?i)\\.mov$",
              /*mime_type=*/"(?i)video\\/quicktime",
          },
          {
              /*extension=*/"\\.mkv$",
              /*mime_type=*/"video\\/x\\-matroska",
          },
          {
              /*extension=*/"(?i)\\.m(p4|4v|pg|peg|pg4|peg4)$",
              /*mime_type=*/"(?i)video\\/mp(4|eg)",
          },
          {
              /*extension=*/"(?i)\\.og(m|v|x)$",
              /*mime_type=*/"(?i)(application|video)\\/ogg",
          },
          {
              /*extension=*/"(?i)\\.webm$",
              /*mime_type=*/"(?i)video\\/webm",
          },
      }};

  // First attempt to match based on `mime_type`.
  std::string mime_type;
  if (net::GetMimeTypeFromFile(file_path, &mime_type)) {
    for (const auto& file_match_pattern : kFileMatchPatterns) {
      if (file_match_pattern.second &&
          re2::RE2::FullMatch(mime_type, file_match_pattern.second)) {
        return true;
      }
    }
  }

  // Then attempt to match based on `file_path` extension.
  for (const auto& file_match_pattern : kFileMatchPatterns) {
    if (re2::RE2::FullMatch(file_path.Extension(), file_match_pattern.first))
      return true;
  }

  return false;
}

using ThumbnailDataCallback = base::OnceCallback<void(const std::string& data)>;

// Handles a parsed message sent from image loader extension in response to a
// thumbnail request.
void HandleParsedThumbnailResponse(
    const std::string& request_id,
    ThumbnailDataCallback callback,
    data_decoder::DataDecoder::ValueOrError result) {
  if (!result.has_value()) {
    VLOG(2) << "Failed to parse request response " << result.error();
    std::move(callback).Run("");
    return;
  }

  if (!result->is_dict()) {
    VLOG(2) << "Invalid response format";
    std::move(callback).Run("");
    return;
  }

  const std::string* received_request_id =
      result->GetDict().FindString("taskId");
  const std::string* data = result->GetDict().FindString("data");

  if (!data || !received_request_id || *received_request_id != request_id) {
    std::move(callback).Run("");
    return;
  }

  std::move(callback).Run(*data);
}

// Native message host for communication to the image loader extension.
// It handles a single image request - when the connection to the extension is
// established, it send a message containing an image request to the image
// loader. It closes the connection once it receives a response from the image
// loader.
class ThumbnailLoaderNativeMessageHost : public extensions::NativeMessageHost {
 public:
  ThumbnailLoaderNativeMessageHost(const std::string& request_id,
                                   const std::string& message,
                                   ThumbnailDataCallback callback)
      : request_id_(request_id),
        message_(message),
        callback_(std::move(callback)) {}

  ~ThumbnailLoaderNativeMessageHost() override {
    if (callback_)
      std::move(callback_).Run("");
  }

  void OnMessage(const std::string& message) override {
    if (response_received_)
      return;
    response_received_ = true;

    // Detach the callback from the message host in case the extension closes
    // connection by the time the response is parsed.
    data_decoder::DataDecoder::ParseJsonIsolated(
        message, base::BindOnce(&HandleParsedThumbnailResponse, request_id_,
                                std::move(callback_)));

    client_->CloseChannel("");
    client_ = nullptr;
  }

  void Start(Client* client) override {
    client_ = client;
    client_->PostMessageFromNativeHost(message_);
  }

  scoped_refptr<base::SingleThreadTaskRunner> task_runner() const override {
    return task_runner_;
  }

 private:
  const std::string request_id_;
  const std::string message_;
  ThumbnailDataCallback callback_;

  raw_ptr<Client, ExperimentalAsh> client_ = nullptr;

  bool response_received_ = false;

  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_ =
      base::SingleThreadTaskRunner::GetCurrentDefault();
};

}  // namespace

// Converts a data URL to bitmap.
class ThumbnailLoader::ThumbnailDecoder : public ImageDecoder::ImageRequest {
 public:
  ThumbnailDecoder() = default;

  ThumbnailDecoder(const ThumbnailDecoder&) = delete;
  ThumbnailDecoder& operator=(const ThumbnailDecoder&) = delete;
  ~ThumbnailDecoder() override = default;

  // ImageDecoder::ImageRequest:
  void OnImageDecoded(const SkBitmap& bitmap) override {
    std::move(callback_).Run(&bitmap, base::File::FILE_OK);
  }

  // ImageDecoder::ImageRequest:
  void OnDecodeImageFailed() override {
    std::move(callback_).Run(/*bitmap=*/nullptr, base::File::FILE_ERROR_FAILED);
  }

  void Start(const std::string& data, ThumbnailLoader::ImageCallback callback) {
    DCHECK(!callback_);

    // The data sent from the image loader extension should be in form of a data
    // URL.
    GURL data_url(data);
    if (!data_url.is_valid() || !data_url.SchemeIs(url::kDataScheme)) {
      std::move(callback).Run(/*bitmap=*/nullptr,
                              base::File::FILE_ERROR_FAILED);
      return;
    }

    std::string mime_type, charset, image_data;
    if (!net::DataURL::Parse(data_url, &mime_type, &charset, &image_data)) {
      std::move(callback).Run(/*bitmap=*/nullptr,
                              base::File::FILE_ERROR_FAILED);
      return;
    }

    callback_ = std::move(callback);
    ImageDecoder::Start(this, std::move(image_data));
  }

 private:
  ThumbnailLoader::ImageCallback callback_;
};

ThumbnailLoader::ThumbnailLoader(Profile* profile) : profile_(profile) {}

ThumbnailLoader::~ThumbnailLoader() {
  // Run any pending callbacks to clean them up.
  for (auto it = requests_.begin(); it != requests_.end();) {
    std::move(it->second).Run(nullptr, base::File::Error::FILE_ERROR_ABORT);
    it = requests_.erase(it);
  }
}

ThumbnailLoader::ThumbnailRequest::ThumbnailRequest(
    const base::FilePath& file_path,
    const gfx::Size& size)
    : file_path(file_path), size(size) {}

ThumbnailLoader::ThumbnailRequest::~ThumbnailRequest() = default;

base::WeakPtr<ThumbnailLoader> ThumbnailLoader::GetWeakPtr() {
  return weak_factory_.GetWeakPtr();
}

void ThumbnailLoader::Load(const ThumbnailRequest& request,
                           ImageCallback callback) {
  // Get the file's last modified time - this will be used for cache lookup in
  // the image loader extension.
  GURL source_url = extensions::Extension::GetBaseURLFromExtensionId(
      file_manager::kImageLoaderExtensionId);
  file_manager::util::GetMetadataForPath(
      file_manager::util::GetFileSystemContextForSourceURL(profile_,
                                                           source_url),
      request.file_path,
      storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
          storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
      base::BindOnce(&ThumbnailLoader::LoadForFileWithMetadata,
                     weak_factory_.GetWeakPtr(), request, std::move(callback)));
}

void ThumbnailLoader::LoadForFileWithMetadata(
    const ThumbnailRequest& request,
    ImageCallback callback,
    base::File::Error result,
    const base::File::Info& file_info) {
  if (result != base::File::FILE_OK) {
    std::move(callback).Run(/*bitmap=*/nullptr, result);
    return;
  }

  // Short-circuit icons for folders.
  if (file_info.is_directory) {
    // `FILE_ERROR_NOT_A_FILE` is a special value used to signify that the
    // file for which the thumbnail was requested is actually a folder.
    std::move(callback).Run(/*bitmap=*/nullptr,
                            base::File::FILE_ERROR_NOT_A_FILE);
    return;
  }

  // Short-circuit if unsupported.
  if (!IsSupported(request.file_path)) {
    std::move(callback).Run(/*bitmap=*/nullptr, base::File::FILE_ERROR_ABORT);
    return;
  }

  GURL thumbnail_url;
  if (!file_manager::util::ConvertAbsoluteFilePathToFileSystemUrl(
          profile_, request.file_path,
          extensions::Extension::GetBaseURLFromExtensionId(
              file_manager::kImageLoaderExtensionId),
          &thumbnail_url)) {
    std::move(callback).Run(/*bitmap=*/nullptr, base::File::FILE_ERROR_FAILED);
    return;
  }

  extensions::MessageService* const message_service =
      extensions::MessageService::Get(profile_);
  if (!message_service) {  // May be `nullptr` in tests.
    std::move(callback).Run(/*bitmap=*/nullptr, base::File::FILE_ERROR_FAILED);
    return;
  }

  base::UnguessableToken request_id = base::UnguessableToken::Create();
  requests_[request_id] = std::move(callback);

  // Unfortunately the image loader only supports cropping to square dimensions
  // but a request for a non-cropped, non-square image would result in image
  // distortion. To work around this we always request square images and then
  // crop to requested dimensions on our end if necessary after bitmap decoding.
  const int size = std::max(request.size.width(), request.size.height());

  // Generate an image loader request. The request type is defined in
  // ui/file_manager/image_loader/load_image_request.js.
  base::Value::Dict request_dict;
  request_dict.Set("taskId", base::Value(request_id.ToString()));
  request_dict.Set("url", base::Value(thumbnail_url.spec()));
  request_dict.Set("timestamp", base::TimeToValue(file_info.last_modified));
  // TODO(crbug.com/2650014) : Add an arg to set this to false for sharesheet.
  request_dict.Set("cache", true);
  request_dict.Set("crop", true);
  request_dict.Set("priority", base::Value(1));
  request_dict.Set("width", base::Value(size));
  request_dict.Set("height", base::Value(size));

  std::string request_message;
  base::JSONWriter::Write(request_dict, &request_message);

  // Open a channel to the image loader extension using a message host that send
  // the image loader request.
  auto native_message_host = std::make_unique<ThumbnailLoaderNativeMessageHost>(
      request_id.ToString(), request_message,
      base::BindOnce(&ThumbnailLoader::OnThumbnailLoaded,
                     weak_factory_.GetWeakPtr(), request_id, request.size));
  const extensions::PortId port_id(base::UnguessableToken::Create(),
                                   1 /* port_number */, true /* is_opener */,
                                   extensions::SerializationFormat::kJson);
  auto native_message_port = std::make_unique<extensions::NativeMessagePort>(
      message_service->GetChannelDelegate(), port_id,
      std::move(native_message_host));
  message_service->OpenChannelToExtension(
      extensions::ChannelEndpoint(profile_), port_id,
      extensions::MessagingEndpoint::ForNativeApp(kNativeMessageHostName),
      std::move(native_message_port), file_manager::kImageLoaderExtensionId,
      GURL(), extensions::ChannelType::kNative,
      std::string() /* channel_name */);
}

void ThumbnailLoader::OnThumbnailLoaded(
    const base::UnguessableToken& request_id,
    const gfx::Size& requested_size,
    const std::string& data) {
  if (!requests_.count(request_id))
    return;

  if (data.empty()) {
    RespondToRequest(request_id, requested_size, /*bitmap=*/nullptr,
                     base::File::FILE_ERROR_FAILED);
    return;
  }

  auto thumbnail_decoder = std::make_unique<ThumbnailDecoder>();
  ThumbnailDecoder* thumbnail_decoder_ptr = thumbnail_decoder.get();
  thumbnail_decoders_.emplace(request_id, std::move(thumbnail_decoder));
  thumbnail_decoder_ptr->Start(
      data,
      base::BindOnce(&ThumbnailLoader::RespondToRequest,
                     weak_factory_.GetWeakPtr(), request_id, requested_size));
}

void ThumbnailLoader::RespondToRequest(const base::UnguessableToken& request_id,
                                       const gfx::Size& requested_size,
                                       const SkBitmap* bitmap,
                                       base::File::Error error) {
  thumbnail_decoders_.erase(request_id);
  auto request_it = requests_.find(request_id);
  if (request_it == requests_.end())
    return;

  // To work around cropping limitations of the image loader, we requested a
  // square image. If requested dimensions were non-square, we need to perform
  // additional cropping on our end.
  SkBitmap cropped_bitmap;
  if (bitmap) {
    gfx::Rect cropped_rect(0, 0, bitmap->width(), bitmap->height());
    if (cropped_rect.size() != requested_size) {
      cropped_bitmap = *bitmap;
      cropped_rect.ClampToCenteredSize(requested_size);
      bitmap->extractSubset(&cropped_bitmap, gfx::RectToSkIRect(cropped_rect));
    }
  }

  ImageCallback callback = std::move(request_it->second);
  requests_.erase(request_it);
  std::move(callback).Run(cropped_bitmap.isNull() ? bitmap : &cropped_bitmap,
                          error);
}

}  // namespace ash