// 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 <memory>
#include <optional>
#include <string>

#include "ash/public/cpp/holding_space/holding_space_item.h"
#include "ash/public/cpp/holding_space/holding_space_model.h"
#include "ash/public/cpp/holding_space/holding_space_progress.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/file_path_watcher.h"
#include "base/files/file_util.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/system/sys_info.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "chrome/browser/ash/login/users/fake_chrome_user_manager.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_keyed_service.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_keyed_service_factory.h"
#include "chrome/browser/ui/ash/holding_space/scoped_test_mount_point.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "chromeos/ash/components/browser_context_helper/annotated_account_id.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"
#include "components/account_id/account_id.h"
#include "components/user_manager/scoped_user_manager.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash::phonehub {

namespace {

using CreatePayloadFilesResult =
    CameraRollDownloadManager::CreatePayloadFilesResult;

constexpr char kUserEmail[] = "user@email.com";

std::unique_ptr<TestingProfileManager> CreateTestingProfileManager() {
  auto profile_manager = std::make_unique<TestingProfileManager>(
      TestingBrowserProcess::GetGlobal());
  EXPECT_TRUE(profile_manager->SetUp());
  return profile_manager;
}

}  // namespace

class CameraRollDownloadManagerImplTest : public testing::Test {
 public:
  CameraRollDownloadManagerImplTest()
      : profile_manager_(CreateTestingProfileManager()),
        user_manager_(new ash::FakeChromeUserManager),
        user_manager_owner_(base::WrapUnique(user_manager_.get())) {
    AccountId account_id(AccountId::FromUserEmail(kUserEmail));
    user_manager_->AddUser(account_id);
    user_manager_->LoginUser(account_id, /*set_profile_created_flag=*/false);

    profile_ = profile_manager_->CreateTestingProfile(kUserEmail);
    ash::AnnotatedAccountId::Set(profile_, account_id);
    user_manager_->OnUserProfileCreated(account_id, profile_->GetPrefs());

    holding_space_keyed_service_ =
        HoldingSpaceKeyedServiceFactory::GetInstance()->GetService(profile_);

    downloads_mount_ =
        holding_space::ScopedTestMountPoint::CreateAndMountDownloads(profile_);

    camera_roll_download_manager_ =
        std::make_unique<CameraRollDownloadManagerImpl>(
            GetDownloadPath(), holding_space_keyed_service_);
  }

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

  secure_channel::mojom::PayloadFilesPtr CreatePayloadFiles(
      int64_t payload_id,
      const proto::CameraRollItemMetadata& item_metadata) {
    secure_channel::mojom::PayloadFilesPtr files_created;
    base::RunLoop run_loop;
    camera_roll_download_manager()->CreatePayloadFiles(
        payload_id, item_metadata,
        base::BindLambdaForTesting(
            [&](CreatePayloadFilesResult result,
                std::optional<secure_channel::mojom::PayloadFilesPtr>
                    payload_files) {
              EXPECT_EQ(CreatePayloadFilesResult::kSuccess, result);
              EXPECT_TRUE(payload_files.has_value());
              files_created = std::move(payload_files.value());
              run_loop.Quit();
            }));
    run_loop.Run();
    return files_created;
  }

  CreatePayloadFilesResult CreatePayloadFilesAndGetError(
      int64_t payload_id,
      const proto::CameraRollItemMetadata& item_metadata) {
    CreatePayloadFilesResult error;
    base::RunLoop run_loop;
    camera_roll_download_manager()->CreatePayloadFiles(
        payload_id, item_metadata,
        base::BindLambdaForTesting(
            [&](CreatePayloadFilesResult result,
                std::optional<secure_channel::mojom::PayloadFilesPtr>
                    payload_files) {
              EXPECT_NE(CreatePayloadFilesResult::kSuccess, result);
              EXPECT_FALSE(payload_files.has_value());
              error = result;
              run_loop.Quit();
            }));
    run_loop.Run();
    return error;
  }

  const base::FilePath& GetDownloadPath() const {
    return downloads_mount_->GetRootPath();
  }

  const HoldingSpaceModel* GetHoldingSpaceModel() const {
    return holding_space_keyed_service_->model_for_testing();
  }

  CameraRollDownloadManagerImpl* camera_roll_download_manager() {
    return camera_roll_download_manager_.get();
  }

  content::BrowserTaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  base::HistogramTester histogram_tester_;

 private:
  std::unique_ptr<TestingProfileManager> profile_manager_;
  raw_ptr<TestingProfile> profile_ = nullptr;
  const raw_ptr<ash::FakeChromeUserManager, DanglingUntriaged> user_manager_;
  user_manager::ScopedUserManager user_manager_owner_;
  raw_ptr<HoldingSpaceKeyedService> holding_space_keyed_service_;
  std::unique_ptr<holding_space::ScopedTestMountPoint> downloads_mount_;

  std::unique_ptr<CameraRollDownloadManagerImpl> camera_roll_download_manager_;
};

TEST_F(CameraRollDownloadManagerImplTest, CreatePayloadFiles) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);

  secure_channel::mojom::PayloadFilesPtr payload_files =
      CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  EXPECT_TRUE(payload_files->input_file.IsValid());
  EXPECT_TRUE(payload_files->output_file.IsValid());
  EXPECT_TRUE(payload_files->output_file.created());
  EXPECT_TRUE(base::PathExists(GetDownloadPath().Append("IMG_0001.jpeg")));
  const HoldingSpaceItem* holding_space_item = GetHoldingSpaceModel()->GetItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001.jpeg"));
  EXPECT_TRUE(holding_space_item != nullptr);
  EXPECT_FALSE(holding_space_item->progress().IsComplete());
  EXPECT_EQ(0, holding_space_item->progress().GetValue());
}

TEST_F(CameraRollDownloadManagerImplTest,
       CreatePayloadFilesWithInvalidFileName) {
  proto::CameraRollItemMetadata item_metadata;
  std::string invalid_file_name = "../../secret/IMG_0001.jpeg";
  item_metadata.set_file_name(invalid_file_name);
  item_metadata.set_file_size_bytes(1000);

  CreatePayloadFilesResult error =
      CreatePayloadFilesAndGetError(/*payload_id=*/1234, item_metadata);

  EXPECT_EQ(CreatePayloadFilesResult::kInvalidFileName, error);
  EXPECT_FALSE(base::PathExists(GetDownloadPath().Append(invalid_file_name)));
  EXPECT_FALSE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001.jpeg")));
}

TEST_F(CameraRollDownloadManagerImplTest,
       CreatePayloadFilesWithReusedPayloadId) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  CreatePayloadFilesResult error =
      CreatePayloadFilesAndGetError(/*payload_id=*/1234, item_metadata);

  EXPECT_EQ(CreatePayloadFilesResult::kPayloadAlreadyExists, error);
}

TEST_F(CameraRollDownloadManagerImplTest,
       CreatePayloadFilesWithInsufficientDiskSpace) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  int64_t free_disk_space_bytes =
      base::SysInfo::AmountOfFreeDiskSpace(GetDownloadPath());
  item_metadata.set_file_size_bytes(free_disk_space_bytes + 1);

  CreatePayloadFilesResult error =
      CreatePayloadFilesAndGetError(/*payload_id=*/1234, item_metadata);

  EXPECT_EQ(CreatePayloadFilesResult::kInsufficientDiskSpace, error);
  EXPECT_FALSE(base::PathExists(GetDownloadPath().Append("IMG_0001.jpeg")));
  EXPECT_FALSE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001.jpeg")));
}

TEST_F(CameraRollDownloadManagerImplTest,
       CreatePayloadFilesWithDuplicateNames) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);

  // Simulat the same item being downloaded twice.
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);
  CreatePayloadFiles(/*payload_id=*/-5678, item_metadata);

  EXPECT_TRUE(base::PathExists(GetDownloadPath().Append("IMG_0001.jpeg")));
  EXPECT_TRUE(base::PathExists(GetDownloadPath().Append("IMG_0001 (1).jpeg")));
  EXPECT_TRUE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001.jpeg")));
  EXPECT_TRUE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001 (1).jpeg")));
}

TEST_F(CameraRollDownloadManagerImplTest,
       CreatePayloadFilesWithFilePathCollision) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);

  // Delete the file for this payload after it has been added to holding space.
  // If CreatePayloadFiles is called for the same item again, it will create the
  // file at the same path. However adding the new payload to holding space will
  // fail because the first payload already exists in the model with the same
  // path.
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);
  base::FilePath file_path = GetDownloadPath().Append("IMG_0001.jpeg");
  EXPECT_TRUE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll, file_path));
  EXPECT_TRUE(base::DeleteFile(file_path));

  CreatePayloadFilesResult error =
      CreatePayloadFilesAndGetError(/*payload_id=*/-5678, item_metadata);
  EXPECT_EQ(CreatePayloadFilesResult::kNotUniqueFilePath, error);
}

TEST_F(CameraRollDownloadManagerImplTest, UpdateDownloadProgress) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  int64_t file_size_bytes = 1024 * 30;  // 30 KB;
  item_metadata.set_file_size_bytes(file_size_bytes);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  task_environment_.FastForwardBy(base::Seconds(10));
  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kInProgress,
          /*total_bytes=*/file_size_bytes,
          /*bytes_transferred=*/file_size_bytes / 2));

  const base::FilePath expected_path =
      GetDownloadPath().Append("IMG_0001.jpeg");
  const HoldingSpaceItem* holding_space_item = GetHoldingSpaceModel()->GetItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll, expected_path);
  EXPECT_TRUE(holding_space_item != nullptr);
  EXPECT_FALSE(holding_space_item->progress().IsComplete());
  EXPECT_EQ(0.5f, holding_space_item->progress().GetValue());

  task_environment_.FastForwardBy(base::Seconds(5));
  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kInProgress,
          /*total_bytes=*/file_size_bytes,
          /*bytes_transferred=*/file_size_bytes));
  EXPECT_FALSE(holding_space_item->progress().IsComplete());
  EXPECT_FLOAT_EQ(1, holding_space_item->progress().GetValue().value());

  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kSuccess,
          /*total_bytes=*/file_size_bytes,
          /*bytes_transferred=*/file_size_bytes));
  EXPECT_TRUE(holding_space_item->progress().IsComplete());
  EXPECT_EQ(1, holding_space_item->progress().GetValue());
  // Expected transfer rate is 30 KB / (10 + 5) s = 2 Kb/s
  histogram_tester_.ExpectUniqueSample(
      "PhoneHub.CameraRoll.DownloadItem.TransferRate", 2,
      /*expected_bucket_count=*/1);
}

TEST_F(CameraRollDownloadManagerImplTest,
       UpdateDownloadProgressWithMultiplePayloads) {
  proto::CameraRollItemMetadata item_metadata_1;
  item_metadata_1.set_file_name("IMG_0001.jpeg");
  item_metadata_1.set_file_size_bytes(1000);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata_1);
  proto::CameraRollItemMetadata item_metadata_2;
  item_metadata_2.set_file_name("IMG_0002.jpeg");
  item_metadata_2.set_file_size_bytes(2000);
  CreatePayloadFiles(/*payload_id=*/-5678, item_metadata_2);

  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kSuccess,
          /*total_bytes=*/1000,
          /*bytes_transferred=*/1000));
  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/-5678,
          secure_channel::mojom::FileTransferStatus::kInProgress,
          /*total_bytes=*/2000,
          /*bytes_transferred=*/200));

  const HoldingSpaceItem* holding_space_item_1 =
      GetHoldingSpaceModel()->GetItem(
          HoldingSpaceItem::Type::kPhoneHubCameraRoll,
          GetDownloadPath().Append("IMG_0001.jpeg"));
  EXPECT_TRUE(holding_space_item_1->progress().IsComplete());
  EXPECT_EQ(1, holding_space_item_1->progress().GetValue());
  const HoldingSpaceItem* holding_space_item_2 =
      GetHoldingSpaceModel()->GetItem(
          HoldingSpaceItem::Type::kPhoneHubCameraRoll,
          GetDownloadPath().Append("IMG_0002.jpeg"));
  EXPECT_FALSE(holding_space_item_2->progress().IsComplete());
  EXPECT_EQ(0.1f, holding_space_item_2->progress().GetValue());
}

TEST_F(CameraRollDownloadManagerImplTest,
       UpdateDownloadProgressForCompletedItem) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kSuccess,
          /*total_bytes=*/1000,
          /*bytes_transferred=*/1000));
  // Subsequent updates should be ignored once a download is complete.
  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kInProgress,
          /*total_bytes=*/2000,
          /*bytes_transferred=*/1000));

  const HoldingSpaceItem* holding_space_item = GetHoldingSpaceModel()->GetItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll,
      GetDownloadPath().Append("IMG_0001.jpeg"));
  EXPECT_TRUE(holding_space_item->progress().IsComplete());
  EXPECT_EQ(1, holding_space_item->progress().GetValue());
}

TEST_F(CameraRollDownloadManagerImplTest, CleanupFailedItem) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  base::FilePath expected_path = GetDownloadPath().Append("IMG_0001.jpeg");
  base::RunLoop delete_file_run_loop;
  base::FilePathWatcher watcher;
  watcher.Watch(expected_path, base::FilePathWatcher::Type::kNonRecursive,
                base::BindLambdaForTesting(
                    [&](const base::FilePath& file_path, bool error) {
                      delete_file_run_loop.Quit();
                    }));
  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kInProgress,
          /*total_bytes=*/1000,
          /*bytes_transferred=*/200));

  EXPECT_TRUE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll, expected_path));
  EXPECT_TRUE(base::PathExists(expected_path));

  camera_roll_download_manager()->UpdateDownloadProgress(
      secure_channel::mojom::FileTransferUpdate::New(
          /*payload_id=*/1234,
          secure_channel::mojom::FileTransferStatus::kFailure,
          /*total_bytes=*/1000,
          /*bytes_transferred=*/200));
  delete_file_run_loop.Run();

  EXPECT_FALSE(GetHoldingSpaceModel()->ContainsItem(
      HoldingSpaceItem::Type::kPhoneHubCameraRoll, expected_path));
  EXPECT_FALSE(base::PathExists(expected_path));
}

TEST_F(CameraRollDownloadManagerImplTest, DeleteFile) {
  proto::CameraRollItemMetadata item_metadata;
  item_metadata.set_file_name("IMG_0001.jpeg");
  item_metadata.set_file_size_bytes(1000);
  CreatePayloadFiles(/*payload_id=*/1234, item_metadata);

  base::FilePath expected_path = GetDownloadPath().Append("IMG_0001.jpeg");
  EXPECT_TRUE(base::PathExists(expected_path));
  base::RunLoop delete_file_run_loop;
  base::FilePathWatcher watcher;
  watcher.Watch(expected_path, base::FilePathWatcher::Type::kNonRecursive,
                base::BindLambdaForTesting(
                    [&](const base::FilePath& file_path, bool error) {
                      delete_file_run_loop.Quit();
                    }));

  camera_roll_download_manager()->DeleteFile(/*payload_id=*/1234);
  delete_file_run_loop.Run();

  EXPECT_FALSE(base::PathExists(expected_path));
}

}  // namespace ash::phonehub