#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_ZIPDIRECTORYREADER_H
#define NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPDIRECTORYREADER_H

#include "Nuclex/Storage/Config.h"

#include <memory>
#include <map>
#include <cstdint>
#include <string>

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

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

  class ZippedContainer;
  class ZippedFile;
  class ZipReader;
  struct LocalFileHeader;

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

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

namespace Nuclex { namespace Storage {

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

  class Blob;

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

}} // namespace Nuclex::Storage

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

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

  /// <summary>
  ///   Reads the directory of a zip archive and creates the appropriate objects
  /// </summary>
  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>Map of file names to zipped file informations</summary>
    private: typedef std::map<std::string, ZippedContainerPointer> ZippedContainerMap;

    /// <summary>Initializes a new zip directory reader</summary>
    /// <param name="nativeArchivePath">System-specific path to the zip archive</param>
    /// <param name="archive">Zip archive of which the directory will be read</param>
    public: ZipDirectoryReader(
      const std::string &nativeArchivePath, 
      const std::shared_ptr<Blob> &archive
    );

    /// <summary>Frees all resources owned by the instance</summary>
    public: ~ZipDirectoryReader();

    /// <summary>Reads the zip archive's directory</summary>
    public: void ReadDirectory();

    /// <summary>Returns the root directory level container of the zip archive</summary>
    /// <returns>The container forthe zip archive's root directory level</returns>
    public: const std::shared_ptr<ZippedContainer> &GetRootContainer() const;

    /// <summary>Reads the compressed file headers from the zip archive</summary>
    private: void scanLocalFileHeaders();

    /// <summary>Adds the contents of a local file header to the hierarchy</summary>
    /// <param name="localFileHeader">
    ///   Local file header containing meta data about the compressed file
    /// </param>
    /// <param name="compressedDataPosition">
    ///   Absolute offset of the compressed file contents in the zip archive
    /// </param>
    private: void processLocalFileHeader(
      const LocalFileHeader &localFileHeader, std::uint64_t compressedDataPosition
    );

    /// <summary>Retrieves or creates a new container for the specified path</summary>
    /// <param name="directory">Directory for which the container will be returned</param>
    /// <returns>The container for the specified directory</returns>
    private: const std::shared_ptr<ZippedContainer> &getOrCreateContainerForDirectory(
      const std::string &directory
    );

    /// <summary>Determines the parent directory of the specified directory</summary>
    /// <param name="directory">Directory whose parent directory will be determined</param>
    /// <returns>The parent directory of the specified directory</returns>
    private: static std::string getParentDirectory(const std::string &directory);

    /// <summary>Determines the name of the directory in the specified path</summary>
    /// <param name="path">
    ///   Path from which the name of the deepest directory will be returned
    /// </param>
    /// <returns>The name of the deepest directory in the specified path</returns>
    private: static std::string getDirectoryName(const std::string &path);

    /// <summary>Checks whether the specified path indicates a directory</summary>
    /// <param name="path">Path that will be checked</param>
    /// <returns>True if the specified path is a directory</returns>
    private: static bool isDirectory(const std::string &path);

    private: ZipDirectoryReader(const ZipDirectoryReader &);
    private: ZipDirectoryReader &operator =(const ZipDirectoryReader &);

    /// <summary>Zip archive path in the format native to the operating system</summary>
    private: std::string nativeArchivePath;
    /// <summary>Cache that will be used to extract deflate-compressed files</summary>
    private: std::shared_ptr<ZipReader> zipReader;
    /// <summary>Zip archive the directory reader operates on</summary>
    private: std::shared_ptr<Blob> archive;
    /// <summary>Containers by their paths<summary>
    private: ZippedContainerMap containers;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPDIRECTORYREADER_H