#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_ZIPARCHIVECONTAINER_H
#define NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPARCHIVECONTAINER_H

#include "Nuclex/Storage/Config.h"
#include "Nuclex/Storage/FileSystem/Container.h"
#include "Nuclex/Storage/FileSystem/ContainerFileCodec.h"
#include "ZipReader.h"

#include <map>

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

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

  class ZippedFile;
  class ZippedContainer;

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

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

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

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

  /// <summary>Represents a zip archive as a container</summary>
  class ZipArchiveContainer : public Container,
    public virtual std::enable_shared_from_this<ZipArchiveContainer> {
    friend class ZippedFile;

    /// <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>Initializes a new zip archive based container</summary>
    /// <param name="codecs">Codecs used to open nested container files</param>
    /// <param name="zipFile">The zip archive the container will access</param>
    public: ZipArchiveContainer(
      const std::shared_ptr<ContainerFileCodec> &codecs, const std::shared_ptr<File> &zipFile
    );

    /// <summary>Closes the zip archive and frees all resources used</summary>
    public: virtual ~ZipArchiveContainer();

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

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

    /// <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>Retrieves the file representing the zip archive itself</summary>
    /// <returns>The file through which the zip archive is opened</returns>
    protected: const std::shared_ptr<File> GetZipFile() const { return this->zipFile; }

    /// <summary>Reads the zip archive's director</summary>
    private: void readZipDirectory() const;

    /// <summary>Zip archive the container is accessing</summary>
    private: std::shared_ptr<File> zipFile;
    /// <summary>Set when the zip directory has been read</summary>
    private: mutable std::once_flag zipDirectoryRead;
    /// <summary>Holds the contents of the zip archive's root directory</summary>
    private: mutable std::shared_ptr<ZippedContainer> rootContainer;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPARCHIVECONTAINER_H