/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ANDROIDFW_ASSETSPROVIDER_H
#define ANDROIDFW_ASSETSPROVIDER_H

#include <memory>
#include <string>

#include "android-base/macros.h"
#include "android-base/unique_fd.h"

#include "androidfw/Asset.h"
#include "androidfw/Idmap.h"
#include "androidfw/LoadedArsc.h"
#include "androidfw/misc.h"

struct ZipArchive;

namespace android {

// Interface responsible for opening and iterating through asset files.
struct AssetsProvider {
  static constexpr off64_t kUnknownLength = -1;

  // Opens a file for reading. If `file_exists` is not null, it will be set to `true` if the file
  // exists. This is useful for determining if the file exists but was unable to be opened due to
  // an I/O error.
  std::unique_ptr<Asset> Open(const std::string& path,
                              Asset::AccessMode mode = Asset::AccessMode::ACCESS_RANDOM,
                              bool* file_exists = nullptr) const;

  // Iterate over all files and directories provided by the interface. The order of iteration is
  // stable.
  virtual bool ForEachFile(const std::string& path,
                           const std::function<void(const StringPiece&, FileType)>& f) const = 0;

  // Retrieves the path to the contents of the AssetsProvider on disk. The path could represent an
  // APk, a directory, or some other file type.
  WARN_UNUSED virtual std::optional<std::string_view> GetPath() const = 0;

  // Retrieves a name that represents the interface. This may or may not be the path of the
  // interface source.
  WARN_UNUSED virtual const std::string& GetDebugName() const = 0;

  // Returns whether the interface provides the most recent version of its files.
  WARN_UNUSED virtual bool IsUpToDate() const = 0;

  // Creates an Asset from a file on disk.
  static std::unique_ptr<Asset> CreateAssetFromFile(const std::string& path);

  // Creates an Asset from a file descriptor.
  //
  // The asset takes ownership of the file descriptor. If `length` equals kUnknownLength, offset
  // must equal 0; otherwise, the asset data will be read using the `offset` into the file
  // descriptor and will be `length` bytes long.
  static std::unique_ptr<Asset> CreateAssetFromFd(base::unique_fd fd,
                                                  const char* path,
                                                  off64_t offset = 0,
                                                  off64_t length = AssetsProvider::kUnknownLength);

  virtual ~AssetsProvider() = default;
 protected:
  virtual std::unique_ptr<Asset> OpenInternal(const std::string& path, Asset::AccessMode mode,
                                              bool* file_exists) const = 0;
};

// Supplies assets from a zip archive.
struct ZipAssetsProvider : public AssetsProvider {
  static std::unique_ptr<ZipAssetsProvider> Create(std::string path,
                                                   package_property_t flags);

  static std::unique_ptr<ZipAssetsProvider> Create(base::unique_fd fd,
                                                   std::string friendly_name,
                                                   package_property_t flags,
                                                   off64_t offset = 0,
                                                   off64_t len = kUnknownLength);

  bool ForEachFile(const std::string& root_path,
                   const std::function<void(const StringPiece&, FileType)>& f) const override;

  WARN_UNUSED std::optional<std::string_view> GetPath() const override;
  WARN_UNUSED const std::string& GetDebugName() const override;
  WARN_UNUSED bool IsUpToDate() const override;
  WARN_UNUSED std::optional<uint32_t> GetCrc(std::string_view path) const;

  ~ZipAssetsProvider() override = default;
 protected:
  std::unique_ptr<Asset> OpenInternal(const std::string& path, Asset::AccessMode mode,
                                      bool* file_exists) const override;

 private:
  struct PathOrDebugName;
  ZipAssetsProvider(ZipArchive* handle, PathOrDebugName&& path, package_property_t flags,
                    time_t last_mod_time);

  struct PathOrDebugName {
    PathOrDebugName(std::string&& value, bool is_path);

    // Retrieves the path or null if this class represents a debug name.
    WARN_UNUSED const std::string* GetPath() const;

    // Retrieves a name that represents the interface. This may or may not represent a path.
    WARN_UNUSED const std::string& GetDebugName() const;

   private:
    std::string value_;
    bool is_path_;
  };

  std::unique_ptr<ZipArchive, void (*)(ZipArchive*)> zip_handle_;
  PathOrDebugName name_;
  package_property_t flags_;
  time_t last_mod_time_;
};

// Supplies assets from a root directory.
struct DirectoryAssetsProvider : public AssetsProvider {
  static std::unique_ptr<DirectoryAssetsProvider> Create(std::string root_dir);

  bool ForEachFile(const std::string& path,
                   const std::function<void(const StringPiece&, FileType)>& f) const override;

  WARN_UNUSED std::optional<std::string_view> GetPath() const override;
  WARN_UNUSED const std::string& GetDebugName() const override;
  WARN_UNUSED bool IsUpToDate() const override;

  ~DirectoryAssetsProvider() override = default;
 protected:
  std::unique_ptr<Asset> OpenInternal(const std::string& path,
                                      Asset::AccessMode mode,
                                      bool* file_exists) const override;

 private:
  explicit DirectoryAssetsProvider(std::string&& path, time_t last_mod_time);
  std::string dir_;
  time_t last_mod_time_;
};

// Supplies assets from a `primary` asset provider and falls back to supplying assets from the
// `secondary` asset provider if the asset cannot be found in the `primary`.
struct MultiAssetsProvider : public AssetsProvider {
  static std::unique_ptr<AssetsProvider> Create(std::unique_ptr<AssetsProvider>&& primary,
                                                std::unique_ptr<AssetsProvider>&& secondary);

  bool ForEachFile(const std::string& root_path,
                   const std::function<void(const StringPiece&, FileType)>& f) const override;

  WARN_UNUSED std::optional<std::string_view> GetPath() const override;
  WARN_UNUSED const std::string& GetDebugName() const override;
  WARN_UNUSED bool IsUpToDate() const override;

  ~MultiAssetsProvider() override = default;
 protected:
  std::unique_ptr<Asset> OpenInternal(
      const std::string& path, Asset::AccessMode mode, bool* file_exists) const override;

 private:
  MultiAssetsProvider(std::unique_ptr<AssetsProvider>&& primary,
                      std::unique_ptr<AssetsProvider>&& secondary);

  std::unique_ptr<AssetsProvider> primary_;
  std::unique_ptr<AssetsProvider> secondary_;
  std::optional<std::string_view> path_;
  std::string debug_name_;
};

// Does not provide any assets.
struct EmptyAssetsProvider : public AssetsProvider {
  static std::unique_ptr<AssetsProvider> Create();
  static std::unique_ptr<AssetsProvider> Create(const std::string& path);

  bool ForEachFile(const std::string& path,
                  const std::function<void(const StringPiece&, FileType)>& f) const override;

  WARN_UNUSED std::optional<std::string_view> GetPath() const override;
  WARN_UNUSED const std::string& GetDebugName() const override;
  WARN_UNUSED bool IsUpToDate() const override;

  ~EmptyAssetsProvider() override = default;
 protected:
  std::unique_ptr<Asset> OpenInternal(const std::string& path, Asset::AccessMode mode,
                                      bool* file_exists) const override;

 private:
  explicit EmptyAssetsProvider(std::optional<std::string>&& path);
  std::optional<std::string> path_;
};

}  // namespace android

#endif /* ANDROIDFW_ASSETSPROVIDER_H */