#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_GENERICWINDOWSCONTAINER_H
#define NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICWINDOWSCONTAINER_H

#include "Nuclex/Storage/Config.h"

#if defined(NUCLEX_STORAGE_WIN32) || defined(NUCLEX_STORAGE_WINRT)

#include "Nuclex/Storage/FileSystem/Container.h"
#include "Nuclex/Storage/FileSystem/ContainerFileCodec.h"
#include "GenericWindowsFile.h"
#include "../../Helpers/StringHelper.h"
#include "../../Helpers/WindowsApi.h"

#include <vector>

namespace Nuclex { namespace Storage { namespace FileSystem {

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

  /// <summary>Directory on a Windows system using either Win32 or WinRT</summary>
  /// <typeparam name="TFileApi">
  ///   A class wrapping the API-specific file system methods
  /// </typeparam>
  /// <typeparam name="TPathHelper">
  ///   A class containing helper methods for working with paths on the platform
  /// </typeparam>
  /// <remarks>
  ///   The differences between Win32 and WinRT are minor as far as file handling
  ///   is concerned, so both share this class to perform their file acccesses,
  ///   using the FileApi and PathHelper to handle the API differences.
  /// </remarks>
  template<typename TFileApi, typename TPathHelper>
  class GenericWindowsContainer : public Container {

    #pragma region class FindHandleScope

    /// <summary>Automatically closes a find handle when the scope is left</summary>
    private: class FindHandleScope {
      /// <summary>Initializes a new find handle scope</summary>
      /// <param name="findHandle">Find handle that will be closed when the scope is left</param>
      public: FindHandleScope(HANDLE findHandle) : findHandle(findHandle) {}
      /// <summary>Closes the find handle</summary>
      public: ~FindHandleScope() { TFileApi::CloseSearch(this->findHandle); }
      /// <summary>Find handle the scope will close</summary>
      private: HANDLE findHandle;
    };

    #pragma endregion // class FindHandleScope

    /// <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>A vector of strings</summary>
    private: typedef std::vector<std::string> StringVector;
    /// <summary>Type of files this container is dealing with</summary>
    private: typedef GenericWindowsFile<TFileApi, TPathHelper> TFile;

    /// <summary>Initializes a new windows container</summary>
    /// <param name="codecs">Codecs used to open files as containers</param>
    /// <param name="absolutePath">Absolute path of the directory</param>
    public: GenericWindowsContainer(
      const std::shared_ptr<ContainerFileCodec> &codecs,
      const std::string &absolutePath
    ) :
      Container(codecs),
      path(absolutePath),
      name(TPathHelper::GetLastPathElement(absolutePath)) {}

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

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

    /// <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::pair<StringVector, StringVector> contents = enumerate(this->path, wildcard);

      std::vector<ConstContainerPointer> containers(contents.second.size());
      for(std::size_t index = 0; index < contents.second.size(); ++index) {
        containers[index] = std::shared_ptr<const Container>(
          new GenericWindowsContainer(this->Codecs, contents.second[index])
        );
      }
      for(std::size_t index = 0; index < contents.first.size(); ++index) {
        std::shared_ptr<File> file(new TFile(contents.first[index]));

        std::shared_ptr<Container> container;
        bool wasOpened = this->Codecs->TryOpenAsContainer(
          this->Codecs, file, container
        );

        if(wasOpened) {
          containers.push_back(container);
        }
      }

      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: virtual std::vector<ContainerPointer> GetContainers(
      const std::string &wildcard = std::string()
    ) {
      std::pair<StringVector, StringVector> contents = enumerate(this->path, wildcard);

      std::vector<ContainerPointer> containers(contents.second.size());
      for(std::size_t index = 0; index < contents.second.size(); ++index) {
        containers[index] = std::shared_ptr<Container>(
          new GenericWindowsContainer(this->Codecs, contents.second[index])
        );
      }

      for(std::size_t index = 0; index < contents.first.size(); ++index) {
        std::shared_ptr<File> file(new TFile(contents.first[index]));

        std::shared_ptr<Container> container;
        bool wasOpened = this->Codecs->TryOpenAsContainer(
          this->Codecs, file, container
        );

        if(wasOpened) {
          containers.push_back(container);
        }
      }

      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: virtual ConstContainerPointer GetContainer(const std::string &name) const {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("Directory does not exist");
      }

      if(isFile(attributes)) {
        std::shared_ptr<File> file(new TFile(containerPath));

        std::shared_ptr<Container> container;
        bool wasOpened = this->Codecs->TryOpenAsContainer(this->Codecs, file, container);
        if(wasOpened) {
          return container;
        } else {
          throw std::runtime_error("Could not open this file as a container");
        }
      }

      return ConstContainerPointer(new GenericWindowsContainer(this->Codecs, containerPath));
    }

    /// <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) {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("Directory does not exist");
      }

      if(isFile(attributes)) {
        std::shared_ptr<File> file(new TFile(containerPath));

        std::shared_ptr<Container> container;
        bool wasOpened = this->Codecs->TryOpenAsContainer(this->Codecs, file, container);
        if(wasOpened) {
          return container;
        } else {
          throw std::runtime_error("Could not open this file as a container");
        }
      }

      return ContainerPointer(new GenericWindowsContainer(this->Codecs, containerPath));
    }

    /// <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 {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        return false;
      } else if((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
        std::shared_ptr<File> file(new TFile(containerPath));
        return this->Codecs->CanOpenAsContainer(file);
      } 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: virtual ContainerPointer CreateContainer(const std::string &name) {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes != INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("Directory or file with same name already exists");
      }

      TFileApi::CreateDirectory(containerPath);

      // TODO: Allow container file codecs to create containers
      return ContainerPointer(new GenericWindowsContainer(this->Codecs, containerPath));
    }

    /// <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) {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        return false;
      }

      if((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
        std::shared_ptr<File> file(new TFile(containerPath));
        if(this->Codecs->CanOpenAsContainer(file)) {
          file.reset();
          TFileApi::DeleteFile(containerPath);
        } else {
          throw std::runtime_error("Cannot delete a file as a directory");
        }
      } else {
        TFileApi::DeleteDirectory(containerPath);
      }

      return true;
    }

    /// <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 {
      std::pair<StringVector, StringVector> contents = enumerate(this->path, wildcard);
      StringVector &filePaths = contents.first;

      std::vector<ConstFilePointer> files(filePaths.size());
      for(std::size_t index = 0; index < filePaths.size(); ++index) {
        files[index] = std::shared_ptr<const File>(new TFile(filePaths[index]));
      }

      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: virtual std::vector<FilePointer> GetFiles(
      const std::string &wildcard = std::string()
    ) {
      std::pair<StringVector, StringVector> contents = enumerate(this->path, wildcard);
      StringVector &filePaths = contents.first;

      std::vector<FilePointer> files(filePaths.size());
      for(std::size_t index = 0; index < filePaths.size(); ++index) {
        files[index] = std::shared_ptr<File>(new TFile(filePaths[index]));
      }

      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: virtual ConstFilePointer GetFile(const std::string &name) const {
      std::string filePath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(filePath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("File does not exist");
      }

      if((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
        throw std::runtime_error("Could not open directory as a file");
      }

      return ConstFilePointer(new TFile(filePath));
    }

    /// <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) {
      std::string filePath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(filePath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("File does not exist");
      }

      if((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
        throw std::runtime_error("Could not open directory as a file");
      }

      return FilePointer(new TFile(filePath));
    }

    /// <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 {
      std::string containerPath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(containerPath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        return false; // Doesn't exist
      } else if((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
        return true; // Is a file
      } else {
        return false; // Is a directory
      }
    }

    /// <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) {
      std::string filePath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(filePath);
      if(attributes != INVALID_FILE_ATTRIBUTES) {
        throw std::runtime_error("File or directory with the same name already exists");
      }

      // Make sure the file is created right away
      FilePointer newFile(new TFile(filePath));
      newFile->WriteAt(0, nullptr, 0);

      return newFile;
    }

    /// <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 existed and was deleted, false if it didn't exist</returns>
    /// <remarks>
    ///   This method can silently ignore when a file does not exist but will 
    /// </remarks>
    public: virtual bool DeleteFile(const std::string &name) {
      std::string filePath = TPathHelper::MakeAbsolute(this->path, name);

      DWORD attributes = TFileApi::GetFileAttributes(filePath);
      if(attributes == INVALID_FILE_ATTRIBUTES) {
        return false;
      }

      if((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
        throw std::runtime_error("Could not delete directory as a file");
      }

      TFileApi::DeleteFile(filePath);

      return true;
    }

    /// <summary>Builds a search mask from a directory and file mask</summary>
    /// <param name="directory">Directory the search will take place in</param>
    /// <param name="wildcard">
    ///   Mask of files that will be searched for. If empty, the search will include all files.
    /// </param>
    /// <returns>The search mask for Windows' FindFile() functions</returns>
    private: static std::string getSearchMask(
      const std::string &directory, const std::string &wildcard
    ) {
      std::string searchMask = directory;

      // If a directory was specified, prepend it to the search mask
      if(!searchMask.empty()) {
        TPathHelper::AddTrailingPathSeparator(searchMask);
      }

      // If no wildcard is specified, use "*.*". Otherwise, append the wildcard.
      if(wildcard.empty()) {
        static const char searchMaskChars[] = "*.*\0";
        searchMask.append(searchMaskChars, 3);
      } else {
        searchMask.append(wildcard);
      }

      return searchMask;
    }

    /// <summary>Enumerates all directories matching a wildcard</summary>
    /// <param name="directory">Directory whose sub directories will be enumerated</param>
    /// <param name="wildcard">Wildcard by which the search will be restricted</param>
    /// <param name="includeDirectories">Whether directories should also be enumerated</param>
    /// <returns>
    ///   A pair containing the directories in .first and the files in .second
    /// </returns>
    public: static std::pair<StringVector, StringVector> enumerate(
      const std::string &directory, const std::string &wildcard, bool includeDirectories = true
    ) {
      using namespace Nuclex::Storage;
      using namespace Nuclex::Storage::FileSystem;

      WIN32_FIND_DATAW findData = {0};

      // Build a search mask that the FindFirstFile() function understands
      std::string searchMask = getSearchMask(directory, wildcard);
      HANDLE searchHandle = TFileApi::FindFirstFile(searchMask, findData);
      if(searchHandle == INVALID_HANDLE_VALUE) {
        return std::make_pair(StringVector(), StringVector());
      }

      // Process everything the file API enumerates for us
      StringVector directories, files;
      FindHandleScope findHandleScope(searchHandle); {
        for(;;) {
          if(isFile(findData.dwFileAttributes)) {
            std::string filename = Helpers::StringHelper::Utf8FromWideChar(findData.cFileName);
            files.push_back(TPathHelper::MakeAbsolute(directory, filename));
          } else if(includeDirectories) {
            if((findData.cFileName[0] != L'\0') && (findData.cFileName[0] != L'.')) {
              std::string filename = Helpers::StringHelper::Utf8FromWideChar(findData.cFileName);
              directories.push_back(TPathHelper::MakeAbsolute(directory, filename));
            }
          }

          // Advance to the next file or directory
          if(!TFileApi::FindNextFile(searchHandle, findData)) {
            break;
          }
        }
      } // findhandleScope

      return std::make_pair(files, directories);
    }

    /// <summary>Determines if the specified attributes indicate a file</summary>
    /// <param name="fileAttributes">Attributes that will be checked</param>
    /// <returns>True if the attributes indicated a file, otherwise false</returns>
    private: static bool isFile(DWORD fileAttributes) {
      return
        ((fileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) &&
        ((fileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0);
    }

    /// <summary>Absolute path of the directory</summary>
    private: std::string path;
    /// <summary>The directory's name</summary>
    private: std::string name;

  };

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

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

#endif // defined(NUCLEX_STORAGE_WIN32) || defined(NUCLEX_STORAGE_WINRT)
#endif // NUCLEX_STORAGE_FILESYSTEM_GENERIC_GENERICWINDOWSCONTAINER_H