// 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/ui/ash/projector/pending_screencast_manager.h"

#include <memory>
#include <optional>
#include <vector>

#include "ash/constants/ash_features.h"
#include "ash/projector/projector_metrics.h"
#include "ash/webui/projector_app/public/mojom/projector_types.mojom-forward.h"
#include "base/check.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/json/json_reader.h"
#include "base/json/json_writer.h"
#include "base/strings/strcat.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/ui/ash/projector/projector_utils.h"
#include "chromeos/ash/components/drivefs/mojom/drivefs.mojom.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/url_util.h"

namespace {

constexpr char kOpenUrlBase[] = "https://drive.google.com/open";
constexpr char kDriveRequestContentHintsKey[] = "contentHints";
constexpr char kDriveRequestIndexableTextKey[] = "indexableText";

// The metadata might not be ready as the file gets uploaded. On projector app
// side, we fetch newly uploaded screencasts with 2s delay, and it works fine,
// so put 3s here to allow Drive to populate the metadata.
constexpr base::TimeDelta kDriveGetMetadataDelay = base::Seconds(3);

bool IsWebmOrProjectorFile(const base::FilePath& path) {
  return IsMediaFile(path) || IsMetadataFile(path);
}

// "Absolute path" is the DriveFS absolute path of `drive_relative_path` on
// local file system, for example: absolute_path =
// "/{$drivefs_mounted_point}/root/{$drive_relative_path}";
base::FilePath GetLocalAbsolutePath(const base::FilePath& drivefs_mounted_point,
                                    const base::FilePath& drive_relative_path) {
  base::FilePath root("/");
  base::FilePath absolute_path(drivefs_mounted_point);
  root.AppendRelativePath(drive_relative_path, &absolute_path);
  return absolute_path;
}

// Returns the Drive server side id from |url| e.g.
// https://drive.google.com/open?id=[ID].
std::optional<std::string> GetIdFromDriveUrl(const GURL& url) {
  const std::string& spec = url.spec();
  if (!base::StartsWith(spec, kOpenUrlBase,
                        base::CompareCase::INSENSITIVE_ASCII)) {
    return std::nullopt;
  }
  std::string id;
  if (!net::GetValueForKeyInQuery(url, "id", &id)) {
    return std::nullopt;
  }
  return id;
}

// Retrieves the file id from `metadata` and runs the `get_file_id_callback`
// callback.
void ParseFileIdOnGetMetaData(
    PendingScreencastManager::OnGetFileIdCallback get_file_id_callback,
    const base::FilePath& local_file_path,
    drive::FileError error,
    drivefs::mojom::FileMetadataPtr metadata) {
  std::string file_id;
  // TODO(b/232282526): Add metric to track how often we get metadata failed.
  if (error != drive::FileError::FILE_ERROR_OK || !metadata) {
    LOG(ERROR) << "Get Drive File metadata failed";
  } else if (metadata->alternate_url.empty()) {
    LOG(ERROR) << "No alternate_url found in file metadata";
  } else {
    // TODO(b/221078840): Use the file id directly when it is available in
    // `metadata`.
    std::optional<std::string> parsed_file_id =
        GetIdFromDriveUrl(GURL(metadata->alternate_url));
    if (parsed_file_id.has_value()) {
      file_id = parsed_file_id.value();
    } else {
      LOG(ERROR) << "Could not get file id from alternate url";
    }
  }

  std::move(get_file_id_callback).Run(local_file_path, file_id);
}

// Gets the absolute path for `drive_relative_path` and gets Drive metadata for
// the given file path. To execute the `callback`, we need to know the server
// side file id, which could be learned from metadata.
void GetDriveFileMetadata(
    const base::FilePath& drive_relative_path,
    PendingScreencastManager::OnGetFileIdCallback callback) {
  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  auto* drive_integration_service =
      ProjectorDriveFsProvider::GetActiveDriveIntegrationService();
  if (!drive_integration_service) {
    return;
  }
  const base::FilePath local_path = GetLocalAbsolutePath(
      drive_integration_service->GetMountPointPath(), drive_relative_path);

  // drive::DriveIntegrationService::GetMetadata should only be called on UI
  // thread.
  drive_integration_service->GetMetadata(
      local_path, base::BindOnce(&ParseFileIdOnGetMetaData, std::move(callback),
                                 local_path));
}

// Reads the screencast metadata file from `metadata_file_local_path`. A sample
// file content:
// {
//   "captionLanguage":"en",
//   "captions":[
//     {
//      "endOffset":1260,
//      "hypothesisParts:[],
//      "startOffset":760,
//      "text":"abcd",
//     }
//   ],
//   "tableOfContent":[]
// }
// Returns the indexable text concated by all "text" fields content.
std::string GetIndexableText(const base::FilePath& metadata_file_local_path) {
  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  std::string indexable_text = "";

  // Reads the Json content in `metadata_file_local_path` to `dict_value`:
  std::string file_content;
  if (!base::ReadFileToString(metadata_file_local_path, &file_content)) {
    return indexable_text;
  }

  std::optional<base::Value> value(base::JSONReader::Read(file_content));
  if (!value) {
    return indexable_text;
  }

  const base::Value::Dict* dict_value = value.value().GetIfDict();
  if (!dict_value) {
    return indexable_text;
  }

  // Concats all captions' text:
  const auto* captions = dict_value->FindList("captions");
  if (!captions) {
    return indexable_text;
  }

  for (const auto& caption : *captions) {
    const base::Value::Dict* caption_dict = caption.GetIfDict();
    if (!caption_dict) {
      continue;
    }
    const std::string* text = caption_dict->FindString("text");
    if (text && !text->empty()) {
      base::StrAppend(&indexable_text, {" ", *text});
    }
  }
  return indexable_text;
}

// Returns the request body, which looks like:
// {
//   "contentHints":
//     {
//      "indexableText":"abcd",
//     }
// }
const std::string BuildRequestBody(
    const base::FilePath& metadata_file_local_path) {
  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  const std::string indexable_text = GetIndexableText(metadata_file_local_path);
  if (indexable_text.empty()) {
    return std::string();
  }

  // Builds request body:
  base::Value::Dict root;
  base::Value::Dict contentHints;
  contentHints.Set(kDriveRequestIndexableTextKey, indexable_text);
  root.Set(kDriveRequestContentHintsKey, std::move(contentHints));

  std::string request_body;
  base::JSONWriter::Write(std::move(root), &request_body);

  return request_body;
}

// Returns a valid pending screencast from `container_absolute_path`.  A valid
// screencast should have 1 media file and 1 metadata file.
std::optional<ash::PendingScreencastContainer> GetPendingScreencastContainer(
    const base::FilePath& container_dir,
    const base::FilePath& drivefs_mounted_point,
    bool upload_failed) {
  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  const base::FilePath container_absolute_path =
      GetLocalAbsolutePath(drivefs_mounted_point, container_dir);
  if (!base::PathExists(container_absolute_path)) {
    return std::nullopt;
  }

  int64_t total_size_in_bytes = 0;
  int media_file_count = 0;
  int metadata_file_count = 0;

  base::Time created_time;
  std::string media_name;

  base::FileEnumerator files(container_absolute_path, /*recursive=*/false,
                             base::FileEnumerator::FILES);

  // Calculates the size of media file and metadata file, and the created time
  // of media.
  for (base::FilePath path = files.Next(); !path.empty(); path = files.Next()) {
    if (IsMetadataFile(path)) {
      total_size_in_bytes += files.GetInfo().GetSize();
      metadata_file_count++;
    } else if (IsMediaFile(path)) {
      base::File::Info info;
      if (!base::GetFileInfo(path, &info)) {
        continue;
      }
      created_time = info.creation_time;
      total_size_in_bytes += files.GetInfo().GetSize();
      media_name = path.BaseName().RemoveExtension().value();
      media_file_count++;
    }

    // Return null if the screencast is not valid.
    if (media_file_count > 1 || metadata_file_count > 1) {
      return std::nullopt;
    }
  }

  // Return null if the screencast is not valid.
  if (media_file_count != 1 || metadata_file_count != 1) {
    return std::nullopt;
  }

  ash::PendingScreencastContainer pending_screencast{container_dir};
  pending_screencast.SetTotalSizeInBytes(total_size_in_bytes);
  pending_screencast.SetName(media_name);
  pending_screencast.SetCreatedTime(created_time);
  pending_screencast.set_upload_failed(upload_failed);

  return pending_screencast;
}

// The `pending_webm_or_projector_events` are new uploading ".webm" or
// ".projector" files' events. The `error_syncing_file` are ".webm" or
// ".projector" files which failed to upload. Checks whether these files are
// valid screencast files. Calculates the upload progress or error state and
// returns valid pending or error screencasts.
ash::PendingScreencastContainerSet ProcessAndGenerateNewScreencasts(
    const std::vector<drivefs::mojom::ItemEvent>&
        pending_webm_or_projector_events,
    const std::set<base::FilePath>& error_syncing_file,
    const base::FilePath drivefs_mounted_point) {
  DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  // The valid screencasts set.
  ash::PendingScreencastContainerSet screencasts;

  if (!base::PathExists(drivefs_mounted_point) ||
      (pending_webm_or_projector_events.empty() &&
       error_syncing_file.empty())) {
    return screencasts;
  }

  // A map of container directory path to pending screencast. Each screencast
  // has a unique container directory path in DriveFS.
  std::map<base::FilePath, ash::PendingScreencastContainer>
      container_to_screencasts;

  // Creates error screencasts from `error_syncing_file`:
  for (const auto& upload_failed_file : error_syncing_file) {
    const base::FilePath container_dir = upload_failed_file.DirName();
    auto new_screencast = GetPendingScreencastContainer(
        container_dir, drivefs_mounted_point, /*upload_failed=*/true);
    if (new_screencast) {
      container_to_screencasts[container_dir] = new_screencast.value();
    }
  }

  // Creates uploading screencasts from `pending_webm_or_projector_events`:

  // The `pending_event.path` is the file path in drive. It looks like
  // "/root/{folder path in drive}/{file name}".
  for (const auto& pending_event : pending_webm_or_projector_events) {
    base::FilePath event_file = base::FilePath(pending_event.path);
    // `container_dir` is the parent folder of `pending_event.path` in drive. It
    // looks like "/root/{folder path in drive}".
    const base::FilePath container_dir = event_file.DirName();

    // During this loop, items of multiple events might be under the same
    // folder.
    auto iter = container_to_screencasts.find(container_dir);
    if (iter != container_to_screencasts.end()) {
      ash::PendingScreencastContainer& entry = iter->second;
      // Calculates remaining untranferred bytes of a screencast by adding up
      // its transferred bytes of its files. `pending_event.bytes_to_transfer`
      // is the total bytes of current file.
      // TODO(b/209854146) Not all files appear in
      // `pending_webm_or_projector_events.bytes_transferred`. The missing files
      // might be uploaded or not uploaded. To get an accurate
      // `bytes_transferred`, use DriveIntegrationService::GetMetadata().
      if (!entry.pending_screencast().upload_failed) {
        entry.SetTotalBytesTransferred(entry.bytes_transferred() +
                                       pending_event.bytes_transferred);
      }

      // Skips getting the size of a folder if it has been validated before.
      continue;
    }

    auto new_screencast = GetPendingScreencastContainer(
        container_dir, drivefs_mounted_point, /*upload_failed=*/false);

    if (new_screencast) {
      new_screencast->SetTotalBytesTransferred(pending_event.bytes_transferred);
      container_to_screencasts[container_dir] = new_screencast.value();
    }
  }

  for (const auto& pair : container_to_screencasts) {
    screencasts.insert(pair.second);
  }

  return screencasts;
}

}  // namespace

// Using base::Unretained for callback is safe since the
// PendingScreencastManager owns the `drive_helper_`.
PendingScreencastManager::PendingScreencastManager(
    PendingScreencastChangeCallback pending_screencast_change_callback)
    : pending_screencast_change_callback_(pending_screencast_change_callback),
      blocking_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
      drive_helper_(base::BindRepeating(
          &PendingScreencastManager::MaybeSwitchDriveFsObservation,
          base::Unretained(this))) {}

PendingScreencastManager::~PendingScreencastManager() = default;

void PendingScreencastManager::OnUnmounted() {
  if (!pending_screencast_cache_.empty()) {
    pending_screencast_cache_.clear();
    // Since DriveFS is unmounted, screencasts stop uploading. Notifies pending
    // screencast status has changed.
    pending_screencast_change_callback_.Run(pending_screencast_cache_);
    last_pending_screencast_change_tick_ = base::TimeTicks();
  }
  error_syncing_files_.clear();
}

// Generates new pending upload screencasts list base on `error_syncing_files_`
// and files from drivefs::mojom::SyncingStatus.
//
// When file in error_syncing_files_ complete uploading, remove from
// `error_syncing_files_` so failed screencasts will be removed from pending
// screencast list.
// TODO(b/200343894): OnSyncingStatusUpdate() gets called for both upload and
// download event. Find a way to filter out the upload event.
void PendingScreencastManager::OnSyncingStatusUpdate(
    const drivefs::mojom::SyncingStatus& status) {
  if (!ProjectorDriveFsProvider::IsDriveFsMounted()) {
    return;
  }
  std::vector<drivefs::mojom::ItemEvent> pending_webm_or_projector_events;
  for (const auto& event : status.item_events) {
    const base::FilePath event_file = base::FilePath(event->path);

    if (event->state == drivefs::mojom::ItemEvent::State::kCompleted) {
      OnFileSyncedCompletely(event_file);
    }

    bool pending =
        event->state == drivefs::mojom::ItemEvent::State::kQueued ||
        event->state == drivefs::mojom::ItemEvent::State::kInProgress;
    // Filters pending ".webm" or ".projector".
    if (!pending || !IsWebmOrProjectorFile(event_file)) {
      continue;
    }

    // We might have received the same event with "kCompleted" state multiple
    // times. The `syncing_metadata_files_` is used to watch the first
    // "kCompleted" state for a file so that we could only update indexable text
    // once.
    if (ash::features::IsProjectorUpdateIndexableTextEnabled() &&
        IsMetadataFile(event_file)) {
      syncing_metadata_files_.emplace(event_file);
    }
    pending_webm_or_projector_events.emplace_back(*event.get());
  }

  // If the `pending_webm_or_projector_events`, `error_syncing_files_` and
  // `pending_screencast_cache_` are empty, return early because the syncing may
  // be triggered by files that are not related to Projector.
  if (pending_webm_or_projector_events.empty() &&
      error_syncing_files_.empty() && pending_screencast_cache_.empty()) {
    return;
  }

  // The `task` is a blocking I/O operation while `reply` runs on current
  // thread.
  // TODO(b/223668878) OnSyncingStatusUpdate might get called multiple times
  // within 1s. Add a repeat timer to trigger this task for less frequency.
  blocking_task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(ProcessAndGenerateNewScreencasts,
                     std::move(pending_webm_or_projector_events),
                     error_syncing_files_,
                     ProjectorDriveFsProvider::GetDriveFsMountPointPath()),
      base::BindOnce(
          &PendingScreencastManager::OnProcessAndGenerateNewScreencastsFinished,
          weak_ptr_factory_.GetWeakPtr(),
          /*task_start_tick=*/base::TimeTicks::Now()));
}

// Observes the Drive OnError event and add the related files to
// `error_syncing_files_`. The validation of a screencast happens in
// OnSyncingStatusUpdate because the drivefs::mojom::SyncingStatus contains the
// info about the file completed uploaded or not and other files status for the
// same screencast.
void PendingScreencastManager::OnError(
    const drivefs::mojom::DriveError& error) {
  base::FilePath error_file = base::FilePath(error.path);
  // mojom::DriveError::Type has 2 types: kCantUploadStorageFull and
  // kPinningFailedDiskFull. Only handle kCantUploadStorageFull so far.
  if (error.type != drivefs::mojom::DriveError::Type::kCantUploadStorageFull ||
      !IsWebmOrProjectorFile(error_file)) {
    return;
  }
  error_syncing_files_.insert(error_file);
}

const ash::PendingScreencastContainerSet&
PendingScreencastManager::GetPendingScreencasts() const {
  return pending_screencast_cache_;
}

void PendingScreencastManager::SetOnGetFileIdCallbackForTest(
    OnGetFileIdCallback callback) {
  on_get_file_id_callback_ = std::move(callback);
}

void PendingScreencastManager::SetOnGetRequestBodyCallbackForTest(
    OnGetRequestBodyCallback callback) {
  on_get_request_body_ = std::move(callback);
}

void PendingScreencastManager::SetProjectorXhrSenderForTest(
    std::unique_ptr<ash::ProjectorXhrSender> xhr_sender) {
  xhr_sender_ = std::move(xhr_sender);
}

void PendingScreencastManager::MaybeSwitchDriveFsObservation() {
  drive::DriveIntegrationService* const service =
      ProjectorDriveFsProvider::GetActiveDriveIntegrationService();
  if (!service) {
    return;
  }

  drivefs::DriveFsHost* const host = service->GetDriveFsHost();
  if (!host || GetHost() == host) {
    return;
  }

  pending_screencast_cache_.clear();
  error_syncing_files_.clear();

  Observe(host);
}

void PendingScreencastManager::ToggleFileSyncingNotificationForPaths(
    const std::vector<base::FilePath>& paths,
    bool suppress) {
  auto* drivefs_integration =
      ProjectorDriveFsProvider::GetActiveDriveIntegrationService();
  if (!drivefs_integration) {
    return;
  }

  Profile* profile = ProfileManager::GetActiveUserProfile();
  for (const auto& path : paths) {
    base::FilePath drive_path;
    drivefs_integration->GetRelativeDrivePath(path, &drive_path);
    if (suppress) {
      paths_notifications_suppressors_[drive_path] = std::make_unique<
          file_manager::ScopedSuppressDriveNotificationsForPath>(profile,
                                                                 drive_path);
    } else {
      paths_notifications_suppressors_.erase(drive_path);
    }
  }
}

void PendingScreencastManager::OnAppActiveStatusChanged(bool is_active) {
  Profile* profile = ProfileManager::GetActiveUserProfile();
  for (auto& [path, suppressor] : paths_notifications_suppressors_) {
    if (is_active) {
      if (!suppressor) {
        // Suppresses notification on app active.
        suppressor = std::make_unique<
            file_manager::ScopedSuppressDriveNotificationsForPath>(profile,
                                                                   path);
      }
    } else {
      // Resumes notification on app inactive.
      suppressor.reset();
    }
  }
}

void PendingScreencastManager::OnProcessAndGenerateNewScreencastsFinished(
    const base::TimeTicks task_start_tick,
    const ash::PendingScreencastContainerSet& screencasts) {
  const base::TimeTicks now = base::TimeTicks::Now();
  ash::RecordPendingScreencastBatchIOTaskDuration(now - task_start_tick);

  // Returns if pending screencasts didn't change.
  if (screencasts == pending_screencast_cache_) {
    return;
  }
  pending_screencast_cache_ = screencasts;

  // Notifies pending screencast status changed.
  pending_screencast_change_callback_.Run(pending_screencast_cache_);
  if (!last_pending_screencast_change_tick_.is_null()) {
    ash::RecordPendingScreencastChangeInterval(
        now - last_pending_screencast_change_tick_);
  }
  // Resets `last_pending_screencast_change_tick_` to null. We don't track time
  // delta between finish uploading and new uploading started.
  last_pending_screencast_change_tick_ =
      pending_screencast_cache_.empty() ? base::TimeTicks() : now;
}

void PendingScreencastManager::OnFileSyncedCompletely(
    const base::FilePath& event_file) {
  // Clean up the system notification suppression for `event_file`.
  paths_notifications_suppressors_.erase(event_file);

  // If observes a error uploaded file is now successfully uploaded, removes
  // it from `error_syncing_files_`:
  error_syncing_files_.erase(event_file);
  if (ash::features::IsProjectorUpdateIndexableTextEnabled()) {
    // If observes a ".projector" file is now successfully uploaded, updates
    // the indexable text and remove it from `syncing_metadata_files_`.
    const auto iter = syncing_metadata_files_.find(event_file);
    if (iter != syncing_metadata_files_.end()) {
      auto on_get_file_id_callback =
          on_get_file_id_callback_
              ? std::move(on_get_file_id_callback_)
              : base::BindOnce(&PendingScreencastManager::OnGetFileId,
                               weak_ptr_factory_.GetWeakPtr());

      // Posts a delayed task to get Drive metadata because the metadata might
      // not be polulated as the file get uploaded. This task has a long chain
      // of callbacks. The calling order is: GetDriveFileMetadata() ->
      // ParseFileIdOnGetMetaData() -> on_get_file_id_callback.
      content::GetUIThreadTaskRunner({})->PostDelayedTask(
          FROM_HERE,
          base::BindOnce(&GetDriveFileMetadata, event_file,
                         std::move(on_get_file_id_callback)),
          kDriveGetMetadataDelay);
      syncing_metadata_files_.erase(iter);
    }
  }
}

void PendingScreencastManager::OnGetFileId(
    const base::FilePath& local_file_path,
    const std::string& file_id) {
  if (file_id.empty()) {
    return;
  }

  base::ThreadPool::PostTaskAndReplyWithResult(
      FROM_HERE, {base::MayBlock()},
      base::BindOnce(&BuildRequestBody, local_file_path),
      on_get_request_body_
          ? base::BindOnce(std::move(on_get_request_body_), file_id)
          : base::BindOnce(&PendingScreencastManager::SendDrivePatchRequest,
                           weak_ptr_factory_.GetWeakPtr(), file_id));
}

void PendingScreencastManager::SendDrivePatchRequest(
    const std::string& file_id,
    const std::string& request_body) {
  DCHECK(!file_id.empty());
  if (request_body.empty()) {
    return;
  }

  if (!xhr_sender_) {
    xhr_sender_ = std::make_unique<ash::ProjectorXhrSender>(
        ash::ProjectorAppClient::Get()->GetUrlLoaderFactory());
  }

  // TODO(b/288457397): Pass the primary account email after email become
  // required to send request with OAuth token.
  xhr_sender_->Send(
      GURL(base::StrCat({ash::kDriveV3BaseUrl, file_id})),
      ash::projector::mojom::RequestType::kPatch, request_body,
      /*use_credentials=*/false,
      /*use_api_key=*/false,
      base::BindOnce([](ash::projector::mojom::XhrResponsePtr xhr_response) {
        if (xhr_response->response_code !=
            ash::projector::mojom::XhrResponseCode::kSuccess) {
          LOG(ERROR) << "Failed to send Drive patch request for file."
                     << " Error: " << xhr_response->response_code;
        }
      }));
}