#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_ZIPPEDFILE_H
#define NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDFILE_H

#include "Nuclex/Storage/Config.h"
#include "Nuclex/Storage/FileSystem/File.h"
#include "Format/CompressionMethod.h"

#include <memory>

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

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

  class ZipArchiveContainer;
  class ZipReader;

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

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

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

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

  /// <summary>File stored in a zip archive</summary>
  class ZippedFile : public File {

    #pragma region struct MetaData

    /// <summary>Data about the compressed file</summary>
    public: struct MetaData {

      /// <summary>Full path of the file in the native system</summary>
      public: std::string NativePath;
      /// <summary>Name of the file</summary>
      public: std::string Filename;
      /// <summary>Offset of the compressed data within the zip archive</summary>
      public: std::uint64_t CompressedDataOffset;
      /// <summary>Length of the file in compressed form</summary>
      public: std::uint64_t CompressedSize;
      /// <summary>Length of the file when it is uncompressed</summary>
      public: std::uint64_t UncompressedSize;
      /// <summary>Compression method used to compress the file's contents</summary>
      public: CompressionMethod::Enum CompressionMethod;
      /// <summary>Time at which the file was last modified</summary>
      public: std::time_t LastModificationTime;

    };

    #pragma endregion // struct MetaData

    /// <summary>Initializes a new file stored in a zip archive</summary>
    /// <param name="zipReader">Cached reader for the file's contents</param>
    /// <param name="metaData">Data describing the compressed file</param>
    public: ZippedFile(
      const std::shared_ptr<ZipReader> &zipReader,
      const MetaData &metaData
    );

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

    /// <summary>Determines the size of the file</summary>
    /// <returns>The size of the file in bytes</returns>
    public: std::uint64_t GetSize() const { return this->metaData.UncompressedSize; }

    /// <summary>Returns the name of the file</summary>
    /// <returns>The file's name</returns>
    public: const std::string &GetName() const { return this->metaData.Filename; }

    /// <summary>Changes the name of the file</summary>
    /// <param name="name">New name the file will be known under</param>
    public: void SetName(const std::string &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->metaData.NativePath; }

    /// <summary>Retrieves the time at which the file has been last modified</summary>
    /// <returns>The since since the last modification of the file took place</returns>
    public: std::time_t GetLastModificationTime() const {
      return this->metaData.LastModificationTime;
    }

    /// <summary>Reads raw data from the file</summary>
    /// <param name="location">Absolute file position data will be read from</param>
    /// <param name="buffer">Buffer into which data will be read</param>
    /// <param name="count">Number of bytes that will be read</param>
    public: void ReadAt(
      std::uint64_t location, void *buffer, std::size_t count
    ) const;

    /// <summary>Writes raw data into the file</summary>
    /// <param name="location">Absolute file position data will be written to</param>
    /// <param name="buffer">Buffer from which data will be taken</param>
    /// <param name="count">Number of bytes that will be written</param>
    public: void WriteAt(
      std::uint64_t location, const void *buffer, std::size_t count
    );

    /// <summary>Ensures changes to the file have been written to disk</summary>
    public: void Flush() {
      // Since writing isn't supported, there's nothing to do here.
    }

    private: ZippedFile(const ZippedFile &);
    private: ZippedFile &operator =(const ZippedFile &);
    
    /// <summary>Decompresses data from the zip archive</summary>
    private: std::shared_ptr<ZipReader> zipReader;
    /// <summary>Describing informations about the compressed file</summary>
    private: MetaData metaData;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDFILE_H