#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_SEVENZIP_SEVENZIPDIRECTORYREADER_H
#define NUCLEX_STORAGE_FILESYSTEM_SEVENZIP_SEVENZIPDIRECTORYREADER_H

#include "Nuclex/Storage/Config.h"

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

namespace Nuclex { namespace Storage { namespace FileSystem { namespace SevenZip {

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

  class SevenZippedContainer;
  class SevenZippedFile;
  class SevenZipArchive;
  class SevenZipReader;
  struct LocalFileHeader;

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

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

namespace Nuclex { namespace Storage {

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

  class Blob;

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

}} // namespace Nuclex::Storage

namespace Nuclex { namespace Storage { namespace FileSystem { namespace SevenZip {

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

  /// <summary>
  ///   Reads the directory of a zip archive and creates the appropriate objects
  /// </summary>
  class SevenZipDirectoryReader {

    /// <summary>Smart pointer to a zipped container</summary>
    private: typedef std::shared_ptr<SevenZippedContainer> SevenZippedContainerPointer;
    /// <summary>Smart pointer to a zipped file</summary>
    private: typedef std::shared_ptr<SevenZippedFile> SevenZippedFilePointer;

    /// <summary>Map of file names to zipped file informations</summary>
    private: typedef std::map<std::string, SevenZippedContainerPointer> SevenZippedContainerMap;

    /// <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: SevenZipDirectoryReader(
      const std::string &nativeArchivePath, 
      const std::shared_ptr<Blob> &archive
    );

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

    /// <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<SevenZippedContainer> &GetRootContainer() const;

    /// <summary>Creates wrappers for the files and folder in the 7-Zip archive</summary>
    private: void readArchiveStructure();

    /// <summary>Adds an archived file to the hierarchy</summary>
    /// <param name="index">Index of the file in the archive</param>
    /// <param name="path">Full path of the file or directory</param>
    /// <param name="isDirectory">Whether the file is a directory</param>
    private: void processArchivedFile(
      std::size_t index, const std::string &path, bool isDirectory
    );

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

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

    /// <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<SevenZipReader> zipReader;
    /// <summary>7-Zip archive that will be accessed by the file wrappers</summary>
    private: std::shared_ptr<SevenZipArchive> sevenZipArchive;
    /// <summary>Containers by their paths<summary>
    private: SevenZippedContainerMap containers;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_SEVENZIP_SEVENZIPDIRECTORYREADER_H