// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_PROVIDED_FILE_SYSTEM_INTERFACE_H_
#define CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_PROVIDED_FILE_SYSTEM_INTERFACE_H_

#include <stdint.h>

#include <map>
#include <memory>
#include <string>
#include <vector>

#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/functional/callback.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/ash/file_system_provider/abort_callback.h"
#include "chrome/browser/ash/file_system_provider/cloud_file_info.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_observer.h"
#include "chrome/browser/ash/file_system_provider/watcher.h"
#include "storage/browser/file_system/async_file_util.h"
#include "storage/browser/file_system/watcher_manager.h"
#include "url/gurl.h"

namespace base {
class Time;
}  // namespace base

namespace net {
class IOBuffer;
}  // namespace net

namespace ash::file_system_provider {

class ProvidedFileSystemInfo;
class OperationRequestManager;

// Represents a file or directory in cloud storage.
struct CloudIdentifier {
  std::string provider_name;
  std::string id;

  CloudIdentifier(const std::string& provider_name, const std::string& id);
  bool operator==(const CloudIdentifier&) const;
};

// Represents metadata for either a file or a directory.
struct EntryMetadata {
  EntryMetadata();

  EntryMetadata(const EntryMetadata&) = delete;
  EntryMetadata& operator=(const EntryMetadata&) = delete;

  ~EntryMetadata();

  // All of the metadata fields are optional. All strings which are set, are
  // non-empty.
  std::unique_ptr<bool> is_directory;
  std::unique_ptr<std::string> name;
  std::unique_ptr<int64_t> size;
  std::unique_ptr<base::Time> modification_time;
  std::unique_ptr<std::string> mime_type;
  std::unique_ptr<std::string> thumbnail;
  std::unique_ptr<CloudIdentifier> cloud_identifier;
  std::unique_ptr<CloudFileInfo> cloud_file_info;
};

// Represents actions for either a file or a directory.
struct Action {
  std::string id;
  std::string title;
};

typedef std::vector<Action> Actions;

// Mode of opening a file. Used by OpenFile().
enum OpenFileMode { OPEN_FILE_MODE_READ, OPEN_FILE_MODE_WRITE };

// Contains information about an opened file.
struct OpenedFile {
  OpenedFile(const base::FilePath& file_path, OpenFileMode mode);
  OpenedFile();
  ~OpenedFile();

  base::FilePath file_path;
  OpenFileMode mode;
};

// Map from a file handle to an OpenedFile struct.
typedef std::map<int, OpenedFile> OpenedFiles;

class ScopedUserInteraction {
 public:
  virtual ~ScopedUserInteraction();
  ScopedUserInteraction(const ScopedUserInteraction&) = delete;
  ScopedUserInteraction& operator=(const ScopedUserInteraction&) = delete;
  ScopedUserInteraction(ScopedUserInteraction&&);
  ScopedUserInteraction& operator=(ScopedUserInteraction&&);

 protected:
  ScopedUserInteraction();
};

// Interface for a provided file system. Acts as a proxy between providers
// and clients. All of the request methods return an abort callback in order to
// terminate it while running. They must be called on the same thread as the
// request methods. The cancellation callback may be null if the operation
// fails synchronously. It must not be called once the operation is completed
// with either a success or an error.
class ProvidedFileSystemInterface {
 public:
  // Fields to be fetched with metadata.
  enum MetadataField {
    METADATA_FIELD_NONE = 0,
    METADATA_FIELD_IS_DIRECTORY = 1 << 0,
    METADATA_FIELD_NAME = 1 << 1,
    METADATA_FIELD_SIZE = 1 << 2,
    METADATA_FIELD_MODIFICATION_TIME = 1 << 3,
    METADATA_FIELD_MIME_TYPE = 1 << 4,
    METADATA_FIELD_THUMBNAIL = 1 << 5,
    METADATA_FIELD_CLOUD_IDENTIFIER = 1 << 6,
    METADATA_FIELD_CLOUD_FILE_INFO = 1 << 7
  };

  // Callback for OpenFile(). In case of an error, file_handle is equal to 0
  // and result is set to an error code.
  typedef base::OnceCallback<void(int file_handle,
                                  base::File::Error result,
                                  std::unique_ptr<EntryMetadata> metadata)>
      OpenFileCallback;

  typedef base::RepeatingCallback<
      void(int chunk_length, bool has_more, base::File::Error result)>
      ReadChunkReceivedCallback;

  typedef base::OnceCallback<void(std::unique_ptr<EntryMetadata> entry_metadata,
                                  base::File::Error result)>
      GetMetadataCallback;

  typedef base::OnceCallback<void(const Actions& actions,
                                  base::File::Error result)>
      GetActionsCallback;

  // Mask of fields requested from the GetMetadata() call.
  typedef int MetadataFieldMask;

  virtual ~ProvidedFileSystemInterface() = default;

  // Requests unmounting of the file system. The callback is called when the
  // request is accepted or rejected, with an error code.
  virtual AbortCallback RequestUnmount(
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests metadata of the passed |entry_path|. It can be either a file
  // or a directory. All |fields| will be returned if supported. Note, that
  // default fields are always returned.
  virtual AbortCallback GetMetadata(const base::FilePath& entry_path,
                                    MetadataFieldMask fields,
                                    GetMetadataCallback callback) = 0;

  // Requests list of actions for the passed list of entries at |entry_paths|.
  // They can be either files or directories.
  virtual AbortCallback GetActions(
      const std::vector<base::FilePath>& entry_paths,
      GetActionsCallback callback) = 0;

  // Executes the |action_id| action on the list of entries at |entry_paths|.
  virtual AbortCallback ExecuteAction(
      const std::vector<base::FilePath>& entry_paths,
      const std::string& action_id,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests enumerating entries from the passed |directory_path|. The callback
  // can be called multiple times until |has_more| is set to false.
  virtual AbortCallback ReadDirectory(
      const base::FilePath& directory_path,
      storage::AsyncFileUtil::ReadDirectoryCallback callback) = 0;

  // Requests opening a file at |file_path|. If the file doesn't exist, then the
  // operation will fail. In case of any error, the returned file handle is 0.
  virtual AbortCallback OpenFile(const base::FilePath& file_path,
                                 OpenFileMode mode,
                                 OpenFileCallback callback) = 0;

  // Requests closing a file, previously opened with OpenFile() as a file with
  // |file_handle|. The |callback| must be called.
  virtual AbortCallback CloseFile(
      int file_handle,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests reading a file previously opened with |file_handle|. The callback
  // can be called multiple times until |has_more| is set to false. On success
  // it should return |length| bytes starting from |offset| in total. It can
  // return less only in case EOF is encountered.
  virtual AbortCallback ReadFile(int file_handle,
                                 net::IOBuffer* buffer,
                                 int64_t offset,
                                 int length,
                                 ReadChunkReceivedCallback callback) = 0;

  // Requests creating a directory. If |recursive| is passed, then all non
  // existing directories on the path will be created. The operation will fail
  // if the target directory already exists.
  virtual AbortCallback CreateDirectory(
      const base::FilePath& directory_path,
      bool recursive,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests creating a file. If the entry already exists, then the
  // FILE_ERROR_EXISTS error must be returned.
  virtual AbortCallback CreateFile(
      const base::FilePath& file_path,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests deleting a directory. If |recursive| is passed and the entry is
  // a directory, then all contents of it (recursively) will be deleted too.
  virtual AbortCallback DeleteEntry(
      const base::FilePath& entry_path,
      bool recursive,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests copying an entry (recursively in case of a directory) within the
  // same file system.
  virtual AbortCallback CopyEntry(
      const base::FilePath& source_path,
      const base::FilePath& target_path,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests moving an entry (recursively in case of a directory) within the
  // same file system.
  virtual AbortCallback MoveEntry(
      const base::FilePath& source_path,
      const base::FilePath& target_path,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests truncating a file to the desired length.
  virtual AbortCallback Truncate(
      const base::FilePath& file_path,
      int64_t length,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests writing to a file previously opened with |file_handle|.
  virtual AbortCallback WriteFile(
      int file_handle,
      net::IOBuffer* buffer,
      int64_t offset,
      int length,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests flushing data written to a file previously opened with
  // `file_handle`. This is currently only called after the last write
  // operation.
  virtual AbortCallback FlushFile(
      int file_handle,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests adding a watcher on an entry. |recursive| must not be true for
  // files. |callback| is optional, but it can't be used for persistent
  // watchers.
  virtual AbortCallback AddWatcher(
      const GURL& origin,
      const base::FilePath& entry_path,
      bool recursive,
      bool persistent,
      storage::AsyncFileUtil::StatusCallback callback,
      storage::WatcherManager::NotificationCallback notification_callback) = 0;

  // Requests removing a watcher, which is immediately deleted from the internal
  // list, hence the operation is not abortable.
  virtual void RemoveWatcher(
      const GURL& origin,
      const base::FilePath& entry_path,
      bool recursive,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Notifies about changes related to the watcher within the file system.
  // Invoked by the file system implementation. Returns an error code via the
  // callback if the notification arguments are malformed or the entry is not
  // watched anymore. On success, returns base::File::FILE_OK.
  // TODO(mtomasz): Replace [entry_path, recursive] with a watcher id.
  virtual void Notify(
      const base::FilePath& entry_path,
      bool recursive,
      storage::WatcherManager::ChangeType change_type,
      std::unique_ptr<ProvidedFileSystemObserver::Changes> changes,
      const std::string& tag,
      storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Requests showing UI for configuring the file system by user. Once the
  // configuration process is completed, base::File::FILE_OK or an error code is
  // returned via the |callback|.
  virtual void Configure(storage::AsyncFileUtil::StatusCallback callback) = 0;

  // Returns a provided file system info for this file system.
  virtual const ProvidedFileSystemInfo& GetFileSystemInfo() const = 0;

  // Returns a mutable list of watchers.
  virtual Watchers* GetWatchers() = 0;

  // Returns a list of opened files.
  virtual const OpenedFiles& GetOpenedFiles() const = 0;

  // Returns a request manager for the file system.
  virtual OperationRequestManager* GetRequestManager() = 0;

  // Adds an observer on the file system.
  virtual void AddObserver(ProvidedFileSystemObserver* observer) = 0;

  // Removes an observer.
  virtual void RemoveObserver(ProvidedFileSystemObserver* observer) = 0;

  // Returns a weak pointer to this object.
  virtual base::WeakPtr<ProvidedFileSystemInterface> GetWeakPtr() = 0;

  // Starts a user interaction with the file system, during which "unresponsive
  // operation" notifications won't be created.
  virtual std::unique_ptr<ScopedUserInteraction> StartUserInteraction() = 0;
};

}  // namespace ash::file_system_provider

#endif  // CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_PROVIDED_FILE_SYSTEM_INTERFACE_H_