#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_ZIPPEDFILEEXTRACTIONCACHE_H
#define NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDFILEEXTRACTIONCACHE_H

#include "Nuclex/Storage/Config.h"
#include "../../Helpers/StreamingCacheContext.h"
#include "ZippedFile.h"

#include <vector>

#include <zlib.h>

namespace Nuclex { namespace Storage {

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

  class Blob;

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

}} // namespace Nuclex::Storage

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

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

  /// <summary>Compares two meta data instances</summary>   
  class MetaDataEqualTo {

    /// <summary>Determines whether two meta data instances refer to the same file</summary>
    /// <param name="left">Meta data instance that will be compared on the left side</param>
    /// <param name="right">Meta data instance that will be compared on the right side</param>
    /// <returns>True if both instances refer to the same file, false otherwise</returns>
    public: bool operator()(
      const ZippedFile::MetaData &left, const ZippedFile::MetaData &right
    ) {
      return left.CompressedDataOffset == right.CompressedDataOffset;
    }

  };

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

  /// <summary>Caches zip decoders to accelerate interleaved extraction of data</summary>
  class ZipReader : public Helpers::Cache<ZippedFile::MetaData, MetaDataEqualTo> {

    #pragma region class DeflateContext

    /// <summary>Maintains a ZLib decompression stream and buffers extracted data</summary>
    protected: class DeflateContext : public Cache::Context {

      /// <summary>Initializes a new zip extraction context</summary>
      /// <param name="blob">Blob containing the data that will be extracted</param>
      /// <param name="metaData">Meta data about the compressed file</param>
      public: DeflateContext(
        const std::shared_ptr<Blob> &blob, const ZippedFile::MetaData &metaData
      );

      /// <summary>Frees all resources owned by the zip extraction context</summary>
      public: virtual ~DeflateContext();

      /// <summary>Reads data from the context</summary>
      /// <param name="location">Location from which data needs to be read</param>
      /// <param name="buffer">Buffer into which the data will be read</param>
      /// <param name="count">Number of bytes that need to be read</param>
      public: virtual void ReadAt(
        std::uint64_t location, void *buffer, std::size_t count
      );

      /// <summary>Skips forward until the specified location is reached</summary>
      /// <param name="location">Location up to which data will be skipped</param>
      private: void skipTo(std::uint64_t location);

      /// <summary>Extracts data using the decompression buffer and provides it</summary>
      /// <param name="location">Location from which on extraction should begin</param>
      /// <param name="buffer">Buffer into which the data will be read</param>
      /// <param name="count">Number of bytes the caller wants to read</param>
      private: void extractUsingBuffer(std::uint8_t *indexableBuffer, std::size_t count);

      /// <summary>Extracts data directly into the caller-provided memory block</summary>
      /// <param name="location">Location from which on extraction should begin</param>
      /// <param name="buffer">Buffer into which the data will be read</param>
      /// <param name="count">Number of bytes the caller wants to read</param>
      /// <returns>The number of bytes remaining to be extracted</returns>
      private: std::size_t extractDirectly(std::uint8_t *indexableBuffer, std::size_t count);

      /// <summary>Fills the input buffer back up</summary>
      private: void refillInputBuffer();

      /// <summary>Blob the context is caching data for</summary>
      private: std::shared_ptr<Blob> blob;
      /// <summary>Stores internal data used by ZLib</summary>
      private: z_stream zlibStream;
      /// <summary>Contains the compressed data</summary>
      private: std::vector<std::uint8_t> compressedData;
      /// <summary>Contains the uncompressed data</summary>
      private: std::vector<std::uint8_t> uncompressedData;
      /// <summary>Current location within the compressed data</summary>
      private: std::uint64_t compressedLocation;
      /// <summary>Number of bytes of compressed data that are remaining</summary>
      private: std::uint64_t compressedRemaining;

    };

    #pragma endregion // class DeflateContext

    /// <summary>Initializes a new zip extraction cache</summary>
    /// <param name="blob">File that will be extracted</param>
    public: ZipReader(const std::shared_ptr<Blob> &blob);

    /// <summary>Frees all resources used by the cache instance</summary>
    public: virtual ~ZipReader() {}

    /// <summary>Reads the specified number of bytes from the file</summary>
    /// <param name="metaData">Meta data about the file being accessed</param>
    /// <param name="position">Absolute file position the data will be read from</param>
    /// <param name="buffer">Buffer into which the data will be read</param>
    /// <param name="count">Number of bytes that will be read</param>
    public: void ReadAt(
      const ZippedFile::MetaData &metaData,
      std::uint64_t position, void *buffer, std::size_t count
    );

    /// <summary>Creates a new context storing the state of a decompressor</summary>
    /// <param name="metaData">
    ///   Informations about the compressed file for which a new context is required
    /// </param>
    /// <returns>The new context</returns>
    protected: virtual Context *CreateContext(const ZippedFile::MetaData &metaData);

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

    /// <summary>File contents that will be extracted</summary>
    private: std::shared_ptr<Blob> blob;

  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_ZIP_ZIPPEDFILEEXTRACTIONCACHE_H