#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 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_ZIP_ZIPPEDCONTAINER_H
#define NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDCONTAINER_H

#include "Nuclex/Storage/Config.h"
#include "Nuclex/Storage/FileSystem/Container.h"
#include "../Generic/GenericArchivedContainer.h"

namespace Nuclex { namespace Storage { namespace FileSystem { namespace Zip {

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

  class ZippedContainer;
  class ZippedFile;
  class ZipDirectoryReader;

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

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

namespace Nuclex { namespace Storage { namespace FileSystem { namespace Zip {

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

  /// <summary>Represents a folder in a zip archive as a container</summary>
  class ZippedContainer : public Container {
    // GenericArchivedContainer<ZippedContainer, ZippedFile>
    friend class ZipDirectoryReader;

    /// <summary>Smart pointer to a zipped container</summary>
    private: typedef std::shared_ptr<ZippedContainer> ZippedContainerPointer;
    /// <summary>Smart pointer to a zipped file</summary>
    private: typedef std::shared_ptr<ZippedFile> ZippedFilePointer;

    /// <summary>Smart pointer to a constant container</summary>
    private: typedef std::shared_ptr<const Container> ConstContainerPointer;
    /// <summary>Smart pointer to a container</summary>
    private: typedef std::shared_ptr<Container> ContainerPointer;

    /// <summary>Smart pointer to a constant file</summary>
    private: typedef std::shared_ptr<const File> ConstFilePointer;
    /// <summary>Smart pointer to a file</summary>
    private: typedef std::shared_ptr<File> FilePointer;

    /// <summary>Map of file names to zipped file informations</summary>
    private: typedef std::map<std::string, ZippedFilePointer> ZippedFileMap;
    /// <summary>Map of file names to zipped file informations</summary>
    private: typedef std::map<std::string, ZippedContainerPointer> ZippedContainerMap;

    /// <summary>Initializes a new zip archive based container</summary>
    /// <param name="codecs">Codecs used to open nested archives</param>
    /// <param name="nativePath">Native path of directory in the zip archive</param>
    /// <param name="name">Name of the container inside the file</param>
    public: ZippedContainer(
      const std::shared_ptr<ContainerFileCodec> &codecs,
      const std::string &nativePath,
      const std::string &name
    );

    /// <summary>Destroys the zipped folder interface</summary>
    public: virtual ~ZippedContainer();

    /// <summary>Returns the name of the file</summary>
    /// <returns>The file's name</returns>
    public: const std::string &GetName() const { return this->name; }

    /// <summary>Returns the path the file is stored at in the native format</summary>
    /// <returns>The file's absolute path in the native OS format</returns>
    public: const std::string &GetNativePath() const { return this->nativePath; }

    /// <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: std::vector<ConstContainerPointer> GetContainers(
      const std::string &wildcard = std::string()
    ) const;

    /// <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<ContainerPointer> GetContainers(
      const std::string &wildcard = std::string()
    );

    /// <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 ConstContainerPointer GetContainer(const std::string &name) const;

    /// <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 ContainerPointer GetContainer(const std::string &name);

    /// <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;

    /// <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 ContainerPointer CreateContainer(const std::string &name);

    /// <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);

    /// <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<ConstFilePointer> GetFiles(
      const std::string &wildcard = std::string()
    ) const;

    /// <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<FilePointer> GetFiles(
      const std::string &wildcard = std::string()
    );

    /// <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 ConstFilePointer GetFile(const std::string &name) const;

    /// <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 FilePointer GetFile(const std::string &name);

    /// <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;

    /// <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 FilePointer CreateFile(const std::string &name);

    /// <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);

    /// <summary>Adds a container as a child of this container</summary>
    /// <param name="container">Container that will be stored inside this container</param>
    protected: void AddContainer(const std::shared_ptr<ZippedContainer> &container);

    /// <summary>Adds a file as a child of this container</summary>
    /// <param name="file">File that will be stored inside this container</param>
    protected: void AddFile(const std::shared_ptr<ZippedFile> &file);

    /// <summary>The native path to this container</summary>
    private: std::string nativePath;
    /// <summary>The container's name</summary>
    private: std::string name;
    /// <summary>Subdirectories inside this directory of the zip archive<summary>
    private: ZippedContainerMap containers;
    /// <summary>Files on this directory level of the zip archive</summary>
    private: ZippedFileMap files;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDCONTAINER_H