#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2021 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_STORAGE_FILESYSTEM_CONTAINER_H
#define NUCLEX_STORAGE_FILESYSTEM_CONTAINER_H

#include "../Config.h"

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

// Safety check for programmers using Windows
//
// Windows.h has the bad habit of globally renaming symbols through a #define.
// When you write myContainer.CreateFile(), what the compiler gets to see is actually
// myContainer.CreateFileW().
//
// If you're developing for Windows and included Windows.h together with Container.h,
// either the compiler will complain because the Container class doesn't have a method
// called CreateFileW() or the symbols in Container.h will have been renamed, too,
// causing linker errors.
//
// Solution: do not include Windows.h
// (or #undef CreateFile + #undef DeleteFile if you must)
// (but really, don't include Windows.h, it's slow and pollutes the global namespace)
#if defined(CreateFile)
#error "CreateFile is globally defined to something else, this WILL cause errors"
#endif
#if defined(DeleteFile)
#error "DeleteFile is globally defined to something else, this WILL cause errors"
#endif

namespace Nuclex { namespace Storage { namespace FileSystem {

  // ------------------------------------------------------------------------------------------- //

  class File;
  class ContainerFileCodec;

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Storage::FileSystem

namespace Nuclex { namespace Storage { namespace FileSystem {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Contains other files or containers</summary>
  /// <remarks>
  ///   Containers are usually plain OS-level directories, but can also be
  ///   archive files (i.e. .zip, .7z) or any other resource that behaves like
  ///   a file system.
  /// </remarks>
  class Container {

    /// <summary>Initializes a new container</summary>
    public: NUCLEX_STORAGE_API Container() = default;

    /// <summary>Destroys the file system interface</summary>
    public: NUCLEX_STORAGE_API virtual ~Container() = default;

    /// <summary>Returns the name of the container</summary>
    /// <returns>The container's name</returns>
    public: virtual const std::string &GetName() const = 0;

    /// <summary>Returns the path the container is stored at in the native format</summary>
    /// <returns>The container's absolute path in the native OS format</returns>
    public: virtual const std::string &GetNativePath() const = 0;

    /// <summary>Creates a list of containers below this one (i.e. subdirectories)</summary>
    /// <param name="wildcard">Wild card by which to filter the enumerated containers</param>
    /// <returns>A list of all containers below this one matching the wildcard</returns>
    public: virtual std::vector<std::string> EnumerateContainers(
      const std::string &wildcard = u8"*"
    ) const = 0;

    /// <summary>Creates a list of all files in this container</summary>
    /// <param name="wildcard">Wild card by which to filter the enumerated files</param>
    /// <returns>A list of all files in this container matching the wildcard</returns>
    public: virtual std::vector<std::string> EnumerateFiles(
      const std::string &wildcard = u8"*"
    ) const = 0;

    /// <summary>Accesses a child container of this container</summary>
    /// <param name="name">Name of the child container that will be accessed</param>
    /// <returns>The child container with the specified name</returns>
    public: virtual std::shared_ptr<Container> AccessContainer(const std::string &name) = 0;

    /// <summary>Accesses a child container of this container</summary>
    /// <param name="name">Name of the child container that will be accessed</param>
    /// <returns>The childcontainer with the specified name</returns>
    public: virtual std::shared_ptr<const Container> AccessContainer(
      const std::string &name
    ) const = 0;

#if 0
    /// <summary>Retrieves a list of the containers located in this container</summary>
    /// <param name="wildcard">Wildcard of the containers to list</param>
    /// <returns>A list of all containers matching the wildcard</returns>
    public: virtual std::vector< std::shared_ptr<const Container> > GetContainers(
      const std::string &wildcard = std::string()
    ) const = 0;

    /// <summary>Retrieves a list of the containers located in this container</summary>
    /// <param name="wildcard">Wildcard of the containers to list</param>
    /// <returns>A list of all containers matching the wildcard</returns>
    public: virtual std::vector< std::shared_ptr<Container> > GetContainers(
      const std::string &wildcard = std::string()
    ) = 0;

    /// <summary>Retrieves the container with the specified name</summary>
    /// <param name="name">Name of the container that will be retrieved</param>
    /// <returns>The container with the specified name</returns>
    public: virtual std::shared_ptr<const Container> GetContainer(
      const std::string &name
    ) const = 0;

    /// <summary>Retrieves the container with the specified name</summary>
    /// <param name="name">Name of the container that will be retrieved</param>
    /// <returns>The container with the specified name</returns>
    public: virtual std::shared_ptr<Container> GetContainer(const std::string &name) = 0;

    /// <summary>Checks if the container contains the specified child container</summary>
    /// <param name="name">Child container the container will be checked for</param>
    /// <returns>True if the container has a child container with the specified name</returns>
    public: virtual bool HasContainer(const std::string &name) const = 0;

    /// <summary>Creates a new container in this container</summary>
    /// <param name="name">Name of the created container</param>
    /// <returns>The created container</returns>
    public: virtual std::shared_ptr<Container> CreateContainer(const std::string &name) = 0;

    /// <summary>Deletes a container in this container</summary>
    /// <param name="name">Name of the deleted container</param>
    /// <returns>True if the container was deleted, false if it didn't exist</returns>
    public: virtual bool DeleteContainer(const std::string &name) = 0;

    /// <summary>Retrieves a list of the files located in this container</summary>
    /// <param name="wildcard">Wildcard of the files to list</param>
    /// <returns>A list of all files matching the wildcard</returns>
    public: virtual std::vector< std::shared_ptr<const File> > GetFiles(
      const std::string &wildcard = std::string()
    ) const = 0;

    /// <summary>Retrieves a list of the files located in this container</summary>
    /// <param name="wildcard">Wildcard of the files to list</param>
    /// <returns>A list of all files matching the wildcard</returns>
    public: virtual std::vector< std::shared_ptr<File> > GetFiles(
      const std::string &wildcard = std::string()
    ) = 0;

    /// <summary>Retrieves the file with the specified name</summary>
    /// <param name="name">Name of the file that will be retrieved</param>
    /// <returns>The file with the specified name</returns>
    public: virtual std::shared_ptr<const File> GetFile(
      const std::string &name
    ) const = 0;

    /// <summary>Retrieves the file with the specified name</summary>
    /// <param name="name">Name of the file that will be retrieved</param>
    /// <returns>The file with the specified name</returns>
    public: virtual std::shared_ptr<File> GetFile(const std::string &name) = 0;

    /// <summary>Checks if the container contains the specified file</summary>
    /// <param name="name">File the container will be checked for</param>
    /// <returns>True if the container contains a file with the specified name</returns>
    public: virtual bool HasFile(const std::string &name) const = 0;

    /// <summary>Retrieves the file with the specified name</summary>
    /// <param name="name">Name of the file that will be retrieved</param>
    /// <returns>The file with the specified name</returns>
    public: virtual std::shared_ptr<File> CreateFile(const std::string &name) = 0;

    /// <summary>Deletes the file with the specified name</summary>
    /// <param name="name">Name of the file that will be deleted</param>
    /// <returns>True if the file was deleted, false if it didn't exist</returns>
    public: virtual bool DeleteFile(const std::string &name) = 0;

    /// <summary>Container file codecs the container uses to open files as containers</summary>
    protected: std::shared_ptr<ContainerFileCodec> Codecs;
#endif

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Storage::FileSystem

#endif // NUCLEX_STORAGE_FILESYSTEM_CONTAINER_H