#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_GENERIC_GENERICARCHIVEDCONTAINER_H
#define NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICARCHIVEDCONTAINER_H

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

#include "../../Helpers/StringHelper.h"

#include <map>

namespace Nuclex { namespace Storage { namespace FileSystem {

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

  /// <summary>Represents a folder in an archive as a container</summary>
  template<typename TArchivedContainer, typename TArchivedFile>
  class GenericArchivedContainer : public Container {

    /// <summary>Smart pointer to a container stored in the archive</summary>
    private: typedef std::shared_ptr<TArchivedContainer> ArchivedContainerPointer;
    /// <summary>Smart pointer to a file stored in the archive</summary>
    private: typedef std::shared_ptr<TArchivedFile> ArchivedFilePointer;

    /// <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 container names to archived containers</summary>
    private: typedef std::map<std::string, ArchivedContainerPointer> ArchivedContainerMap;
    /// <summary>Map of file names to archived files</summary>
    private: typedef std::map<std::string, ArchivedFilePointer> ArchivedFileMap;

    /// <summary>Initializes a new archived container</summary>
    /// <param name="codecs">Codecs used to open nested archives</param>
    /// <param name="nativePath">Native path of the archive file</param>
    /// <param name="name">Name of the archive itself</param>
    public: GenericArchivedContainer(
      const std::shared_ptr<ContainerFileCodec> &codecs,
      const std::string &nativePath,
      const std::string &name
    ) :
      Container(codecs),
      nativePath(nativePath),
      name(name) {}

    /// <summary>Destroys the archived container interface</summary>
    public: virtual ~GenericArchivedContainer() {}

    /// <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 {
      std::vector<ConstContainerPointer> containers;

      if(wildcard.empty()) {
        containers.reserve(this->containers.size());

        ArchivedContainerMap::const_iterator iterator = this->containers.begin();
        for(; iterator != this->containers.end(); ++iterator) {
          containers.push_back(iterator->second);
        }
      } else {
        ArchivedContainerMap::const_iterator iterator = this->containers.begin();
        for(; iterator != this->containers.end(); ++iterator) {
          if(Helpers::StringHelper::MatchesWildcard(iterator->first, wildcard)) {
            containers.push_back(iterator->second);
          }
        }
      }

      return containers;
    }

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

      if(wildcard.empty()) {
        containers.reserve(this->containers.size());

        ArchivedContainerMap::const_iterator iterator = this->containers.begin();
        for(; iterator != this->containers.end(); ++iterator) {
          containers.push_back(iterator->second);
        }
      } else {
        ArchivedContainerMap::const_iterator iterator = this->containers.begin();
        for(; iterator != this->containers.end(); ++iterator) {
          if(Helpers::StringHelper::MatchesWildcard(iterator->first, wildcard)) {
            containers.push_back(iterator->second);
          }
        }
      }

      return containers;
    }

    /// <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: ConstContainerPointer GetContainer(const std::string &name) const {
      ArchivedContainerMap::const_iterator iterator = this->containers.find(name);
      if(iterator == this->containers.end()) {
        throw std::runtime_error("No such container");
      }

      return iterator->second;
    }

    /// <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: ContainerPointer GetContainer(const std::string &name) {
      ArchivedContainerMap::const_iterator iterator = this->containers.find(name);
      if(iterator == this->containers.end()) {
        throw std::runtime_error("No such container");
      }

      return iterator->second;
    }

    /// <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: bool HasContainer(const std::string &name) const {
      ArchivedContainerMap::const_iterator iterator = this->containers.find(name);
      if(iterator == this->containers.end()) {
        ArchivedFileMap::const_iterator iterator = this->files.find(name);
        if(iterator == this->files.end()) {
          return false;
        } else {
          return this->Codecs->CanOpenAsContainer(iterator->second);
        }
      } else {
        return true;
      }
    }

    /// <summary>Creates a new container in this container</summary>
    /// <param name="name">Name of the created container</param>
    /// <returns>The created container</returns>
    public: ContainerPointer CreateContainer(const std::string &name) {
      name;
      throw std::runtime_error("Archives cannot be modified");
    }

    /// <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: bool DeleteContainer(const std::string &name) {
      name;
      throw std::runtime_error("Archives cannot be modified");
    }

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

      if(wildcard.empty()) {
        files.reserve(this->files.size());

        ArchivedFileMap::const_iterator iterator = this->files.begin();
        for(; iterator != this->files.end(); ++iterator) {
          files.push_back(iterator->second);
        }
      } else {
        ArchivedFileMap::const_iterator iterator = this->files.begin();
        for(; iterator != this->files.end(); ++iterator) {
          if(Helpers::StringHelper::MatchesWildcard(iterator->first, wildcard)) {
            files.push_back(iterator->second);
          }
        }
      }

      return files;
    }

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

      if(wildcard.empty()) {
        files.reserve(this->files.size());

        ArchivedFileMap::const_iterator iterator = this->files.begin();
        for(; iterator != this->files.end(); ++iterator) {
          files.push_back(iterator->second);
        }
      } else {
        ArchivedFileMap::const_iterator iterator = this->files.begin();
        for(; iterator != this->files.end(); ++iterator) {
          if(Helpers::StringHelper::MatchesWildcard(iterator->first, wildcard)) {
            files.push_back(iterator->second);
          }
        }
      }

      return files;
    }

    /// <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: ConstFilePointer GetFile(const std::string &name) const {
      ArchivedFileMap::const_iterator iterator = this->files.find(name);
      if(iterator == this->files.end()) {
        throw std::runtime_error("No such file");
      }

      return iterator->second;
    }

    /// <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) {
      ArchivedFileMap::const_iterator iterator = this->files.find(name);
      if(iterator == this->files.end()) {
        throw std::runtime_error("No such file");
      }

      return iterator->second;
    }

    /// <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 {
      ArchivedFileMap::const_iterator iterator = this->files.find(name);
      return (iterator != this->files.end());
    }

    /// <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) {
      name;
      throw std::runtime_error("Archives cannot be modified");
    }

    /// <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) {
      name;
      throw std::runtime_error("Archives cannot be modified");
    }

    /// <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<TArchivedContainer> &container) {
      this->containers.insert(
        ArchivedContainerMap::value_type(container->GetName(), 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<TArchivedFile> &file) {
      this->files.insert(ArchivedFileMap::value_type(file->GetName(), 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: ArchivedContainerMap containers;
    /// <summary>Files on this directory level of the zip archive</summary>
    private: ArchivedFileMap files;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICARCHIVEDCONTAINER_H