// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stddef.h>
#include <stdint.h>

#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "chrome/browser/chromeos/extensions/file_manager/event_router.h"
#include "chrome/browser/chromeos/file_manager/file_watcher.h"
#include "chrome/browser/chromeos/file_manager/mount_test_util.h"
#include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
#include "chrome/browser/extensions/extension_apitest.h"
#include "chrome/common/extensions/api/file_system_provider_capabilities/file_system_provider_capabilities_handler.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/ui_test_utils.h"
#include "chromeos/dbus/cros_disks_client.h"
#include "chromeos/disks/mock_disk_mount_manager.h"
#include "components/drive/file_change.h"
#include "extensions/common/extension.h"
#include "extensions/common/install_warning.h"
#include "google_apis/drive/test_util.h"
#include "storage/browser/fileapi/external_mount_points.h"

using ::testing::_;
using ::testing::ReturnRef;

using chromeos::disks::DiskMountManager;

namespace {

struct TestDiskInfo {
  const char* system_path;
  const char* file_path;
  bool write_disabled_by_policy;
  const char* device_label;
  const char* drive_label;
  const char* vendor_id;
  const char* vendor_name;
  const char* product_id;
  const char* product_name;
  const char* fs_uuid;
  const char* system_path_prefix;
  chromeos::DeviceType device_type;
  uint64_t size_in_bytes;
  bool is_parent;
  bool is_read_only_hardware;
  bool has_media;
  bool on_boot_device;
  bool on_removable_device;
  bool is_hidden;
};

struct TestMountPoint {
  std::string source_path;
  std::string mount_path;
  chromeos::MountType mount_type;
  chromeos::disks::MountCondition mount_condition;

  // -1 if there is no disk info.
  int disk_info_index;
};

TestDiskInfo kTestDisks[] = {
  {
    "system_path1",
    "file_path1",
    false,
    "device_label1",
    "drive_label1",
    "0123",
    "vendor1",
    "abcd",
    "product1",
    "FFFF-FFFF",
    "system_path_prefix1",
    chromeos::DEVICE_TYPE_USB,
    1073741824,
    false,
    false,
    false,
    false,
    false,
    false
  },
  {
    "system_path2",
    "file_path2",
    false,
    "device_label2",
    "drive_label2",
    "4567",
    "vendor2",
    "cdef",
    "product2",
    "0FFF-FFFF",
    "system_path_prefix2",
    chromeos::DEVICE_TYPE_MOBILE,
    47723,
    true,
    true,
    true,
    true,
    false,
    false
  },
  {
    "system_path3",
    "file_path3",
    true,  // write_disabled_by_policy
    "device_label3",
    "drive_label3",
    "89ab",
    "vendor3",
    "ef01",
    "product3",
    "00FF-FFFF",
    "system_path_prefix3",
    chromeos::DEVICE_TYPE_OPTICAL_DISC,
    0,
    true,
    false,  // is_hardware_read_only
    false,
    true,
    false,
    false
  }
};

void DispatchDirectoryChangeEventImpl(
    int* counter,
    const base::FilePath& virtual_path,
    const drive::FileChange* list,
    bool got_error,
    const std::vector<std::string>& extension_ids) {
  ++(*counter);
}

void AddFileWatchCallback(bool success) {}

bool InitializeLocalFileSystem(std::string mount_point_name,
                               base::ScopedTempDir* temp_dir,
                               base::FilePath* mount_point_dir) {
  const char kTestFileContent[] = "The five boxing wizards jumped quickly";
  if (!temp_dir->CreateUniqueTempDir())
    return false;

  *mount_point_dir = temp_dir->GetPath().AppendASCII(mount_point_name);
  // Create the mount point.
  if (!base::CreateDirectory(*mount_point_dir))
    return false;

  const base::FilePath test_dir = mount_point_dir->AppendASCII("test_dir");
  if (!base::CreateDirectory(test_dir))
    return false;

  const base::FilePath test_file = test_dir.AppendASCII("test_file.txt");
  if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
    return false;

  return true;
}

}  // namespace

class FileManagerPrivateApiTest : public ExtensionApiTest {
 public:
  FileManagerPrivateApiTest() : disk_mount_manager_mock_(nullptr) {
    InitMountPoints();
  }

  ~FileManagerPrivateApiTest() override {
    DCHECK(!disk_mount_manager_mock_);
    DCHECK(!testing_profile_);
    DCHECK(!event_router_);
  }

  void SetUpOnMainThread() override {
    ExtensionApiTest::SetUpOnMainThread();

    testing_profile_.reset(new TestingProfile());
    event_router_.reset(new file_manager::EventRouter(testing_profile_.get()));
  }

  void TearDownOnMainThread() override {
    event_router_->Shutdown();

    event_router_.reset();
    testing_profile_.reset();

    ExtensionApiTest::TearDownOnMainThread();
  }

  // ExtensionApiTest override
  void SetUpInProcessBrowserTestFixture() override {
    ExtensionApiTest::SetUpInProcessBrowserTestFixture();
    disk_mount_manager_mock_ = new chromeos::disks::MockDiskMountManager;
    chromeos::disks::DiskMountManager::InitializeForTesting(
        disk_mount_manager_mock_);
    disk_mount_manager_mock_->SetupDefaultReplies();

    // override mock functions.
    ON_CALL(*disk_mount_manager_mock_, FindDiskBySourcePath(_)).WillByDefault(
        Invoke(this, &FileManagerPrivateApiTest::FindVolumeBySourcePath));
    EXPECT_CALL(*disk_mount_manager_mock_, disks())
        .WillRepeatedly(ReturnRef(volumes_));
    EXPECT_CALL(*disk_mount_manager_mock_, mount_points())
        .WillRepeatedly(ReturnRef(mount_points_));
  }

  // ExtensionApiTest override
  void TearDownInProcessBrowserTestFixture() override {
    chromeos::disks::DiskMountManager::Shutdown();
    disk_mount_manager_mock_ = nullptr;

    ExtensionApiTest::TearDownInProcessBrowserTestFixture();
  }

 private:
  void InitMountPoints() {
    const TestMountPoint kTestMountPoints[] = {
      {
        "device_path1",
        chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
            "mount_path1").AsUTF8Unsafe(),
        chromeos::MOUNT_TYPE_DEVICE,
        chromeos::disks::MOUNT_CONDITION_NONE,
        0
      },
      {
        "device_path2",
        chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
            "mount_path2").AsUTF8Unsafe(),
        chromeos::MOUNT_TYPE_DEVICE,
        chromeos::disks::MOUNT_CONDITION_NONE,
        1
      },
      {
        "device_path3",
        chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
            "mount_path3").AsUTF8Unsafe(),
        chromeos::MOUNT_TYPE_DEVICE,
        chromeos::disks::MOUNT_CONDITION_NONE,
        2
      },
      {
        // Set source path inside another mounted volume.
        chromeos::CrosDisksClient::GetRemovableDiskMountPoint().AppendASCII(
            "mount_path3/archive.zip").AsUTF8Unsafe(),
        chromeos::CrosDisksClient::GetArchiveMountPoint().AppendASCII(
            "archive_mount_path").AsUTF8Unsafe(),
        chromeos::MOUNT_TYPE_ARCHIVE,
        chromeos::disks::MOUNT_CONDITION_NONE,
        -1
      }
    };

    for (size_t i = 0; i < arraysize(kTestMountPoints); i++) {
      mount_points_.insert(DiskMountManager::MountPointMap::value_type(
          kTestMountPoints[i].mount_path,
          DiskMountManager::MountPointInfo(kTestMountPoints[i].source_path,
                                           kTestMountPoints[i].mount_path,
                                           kTestMountPoints[i].mount_type,
                                           kTestMountPoints[i].mount_condition)
      ));
      int disk_info_index = kTestMountPoints[i].disk_info_index;
      if (kTestMountPoints[i].disk_info_index >= 0) {
        EXPECT_GT(arraysize(kTestDisks), static_cast<size_t>(disk_info_index));
        if (static_cast<size_t>(disk_info_index) >= arraysize(kTestDisks))
          return;

        volumes_.insert(DiskMountManager::DiskMap::value_type(
            kTestMountPoints[i].source_path,
            base::MakeUnique<DiskMountManager::Disk>(
                kTestMountPoints[i].source_path, kTestMountPoints[i].mount_path,
                kTestDisks[disk_info_index].write_disabled_by_policy,
                kTestDisks[disk_info_index].system_path,
                kTestDisks[disk_info_index].file_path,
                kTestDisks[disk_info_index].device_label,
                kTestDisks[disk_info_index].drive_label,
                kTestDisks[disk_info_index].vendor_id,
                kTestDisks[disk_info_index].vendor_name,
                kTestDisks[disk_info_index].product_id,
                kTestDisks[disk_info_index].product_name,
                kTestDisks[disk_info_index].fs_uuid,
                kTestDisks[disk_info_index].system_path_prefix,
                kTestDisks[disk_info_index].device_type,
                kTestDisks[disk_info_index].size_in_bytes,
                kTestDisks[disk_info_index].is_parent,
                kTestDisks[disk_info_index].is_read_only_hardware,
                kTestDisks[disk_info_index].has_media,
                kTestDisks[disk_info_index].on_boot_device,
                kTestDisks[disk_info_index].on_removable_device,
                kTestDisks[disk_info_index].is_hidden)));
      }
    }
  }

  const DiskMountManager::Disk* FindVolumeBySourcePath(
      const std::string& source_path) {
    auto volume_it = volumes_.find(source_path);
    return (volume_it == volumes_.end()) ? nullptr : volume_it->second.get();
  }

 protected:
  chromeos::disks::MockDiskMountManager* disk_mount_manager_mock_;
  DiskMountManager::DiskMap volumes_;
  DiskMountManager::MountPointMap mount_points_;
  std::unique_ptr<TestingProfile> testing_profile_;
  std::unique_ptr<file_manager::EventRouter> event_router_;
};

IN_PROC_BROWSER_TEST_F(FileManagerPrivateApiTest, Mount) {
  file_manager::test_util::WaitUntilDriveMountPointIsAdded(
      browser()->profile());

  // Add a provided file system, to test passing the |configurable| and
  // |source| flags properly down to Files app.
  chromeos::file_system_provider::ProvidedFileSystemInfo info(
      "testing-extension-id", chromeos::file_system_provider::MountOptions(),
      base::FilePath(), true /* configurable */, false /* watchable */,
      extensions::SOURCE_NETWORK);

  file_manager::VolumeManager::Get(browser()->profile())
      ->AddVolumeForTesting(
          make_linked_ptr(file_manager::Volume::CreateForProvidedFileSystem(
              info, file_manager::MOUNT_CONTEXT_AUTO)));

  // We will call fileManagerPrivate.unmountVolume once. To test that method, we
  // check that UnmountPath is really called with the same value.
  EXPECT_CALL(*disk_mount_manager_mock_, UnmountPath(_, _, _))
      .Times(0);
  EXPECT_CALL(*disk_mount_manager_mock_,
              UnmountPath(
                  chromeos::CrosDisksClient::GetArchiveMountPoint().AppendASCII(
                      "archive_mount_path").AsUTF8Unsafe(),
                  chromeos::UNMOUNT_OPTIONS_NONE, _)).Times(1);

  ASSERT_TRUE(RunComponentExtensionTest("file_browser/mount_test"))
      << message_;
}

IN_PROC_BROWSER_TEST_F(FileManagerPrivateApiTest, Permissions) {
  EXPECT_TRUE(
      RunExtensionTestIgnoreManifestWarnings("file_browser/permissions"));
  const extensions::Extension* extension = GetSingleLoadedExtension();
  ASSERT_TRUE(extension);
  ASSERT_EQ(1u, extension->install_warnings().size());
  const extensions::InstallWarning& warning = extension->install_warnings()[0];
  EXPECT_EQ("fileManagerPrivate", warning.key);
}

IN_PROC_BROWSER_TEST_F(FileManagerPrivateApiTest, OnFileChanged) {
  // In drive volume, deletion of a directory is notified via OnFileChanged.
  // Local changes directly come to HandleFileWatchNotification from
  // FileWatcher.
  typedef drive::FileChange FileChange;
  typedef drive::FileChange::FileType FileType;
  typedef drive::FileChange::ChangeType ChangeType;

  int counter = 0;
  event_router_->SetDispatchDirectoryChangeEventImplForTesting(
      base::Bind(&DispatchDirectoryChangeEventImpl, &counter));

  // /a/b/c and /a/d/e are being watched.
  event_router_->AddFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a/b/c")),
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs-virtual/root/a/b/c")),
      "extension_1", base::Bind(&AddFileWatchCallback));

  event_router_->AddFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a/d/e")),
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs-hash/root/a/d/e")),
      "extension_2", base::Bind(&AddFileWatchCallback));

  event_router_->AddFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/aaa")),
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs-hash/root/aaa")),
      "extension_3", base::Bind(&AddFileWatchCallback));

  // event_router->addFileWatch create some tasks which are performed on message
  // loop of BrowserThread::FILE. Wait until they are done.
  content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
  // We also wait the UI thread here, since some tasks which are performed above
  // message loop back results to the UI thread.
  base::RunLoop().RunUntilIdle();

  // When /a is deleted (1 and 2 is notified).
  FileChange first_change;
  first_change.Update(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a")),
      FileType::FILE_TYPE_DIRECTORY, ChangeType::CHANGE_TYPE_DELETE);
  event_router_->OnFileChanged(first_change);
  EXPECT_EQ(2, counter);

  // When /a/b/c is deleted (1 is notified).
  FileChange second_change;
  second_change.Update(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a/b/c")),
      FileType::FILE_TYPE_DIRECTORY, ChangeType::CHANGE_TYPE_DELETE);
  event_router_->OnFileChanged(second_change);
  EXPECT_EQ(3, counter);

  // When /z/y is deleted (Not notified).
  FileChange third_change;
  third_change.Update(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/z/y")),
      FileType::FILE_TYPE_DIRECTORY, ChangeType::CHANGE_TYPE_DELETE);
  event_router_->OnFileChanged(third_change);
  EXPECT_EQ(3, counter);

  // Remove file watchers.
  event_router_->RemoveFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a/b/c")),
      "extension_1");
  event_router_->RemoveFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/a/d/e")),
      "extension_2");
  event_router_->RemoveFileWatch(
      base::FilePath(FILE_PATH_LITERAL("/no-existing-fs/root/aaa")),
      "extension_3");

  // event_router->removeFileWatch create some tasks which are performed on
  // message loop of BrowserThread::FILE. Wait until they are done.
  content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
}

IN_PROC_BROWSER_TEST_F(FileManagerPrivateApiTest, ContentChecksum) {
  base::ScopedTempDir temp_dir;
  base::FilePath mount_point_dir;
  const char kLocalMountPointName[] = "local";

  ASSERT_TRUE(InitializeLocalFileSystem(kLocalMountPointName, &temp_dir,
                                        &mount_point_dir))
      << "Failed to initialize test file system";

  EXPECT_TRUE(content::BrowserContext::GetMountPoints(browser()->profile())
                  ->RegisterFileSystem(
                      kLocalMountPointName, storage::kFileSystemTypeNativeLocal,
                      storage::FileSystemMountOption(), mount_point_dir));
  file_manager::VolumeManager::Get(browser()->profile())
      ->AddVolumeForTesting(mount_point_dir, file_manager::VOLUME_TYPE_TESTING,
                            chromeos::DEVICE_TYPE_UNKNOWN,
                            false /* read_only */);

  ASSERT_TRUE(RunComponentExtensionTest("file_browser/content_checksum_test"));
}