#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_HELPERS_STREAMINGCACHECONTEXT_H
#define NUCLEX_STORAGE_HELPERS_STREAMINGCACHECONTEXT_H

#include "Nuclex/Storage/Config.h"
#include "Nuclex/Storage/Blob.h"

#include "Cache.h"

#include <vector>
#include <algorithm>

// This ugly wart is needed because some creep at Microsoft thought it would be a good
// idea to define min and max macros (in lowercase) inside Windows.h. And somehow
// Windows.h is getting included here, possibly through the Visual C++ standard headers.
// Shouldn't affect other platforms and if you have macros like this, you're doing it wrong.
#undef min
#undef max

namespace Nuclex { namespace Storage { namespace Helpers {

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

  /// <summary>Cache context that processes data incrementally</summary>
  template <
    typename TIdentifier, typename TComparer = std::equal_to<TIdentifier>
  >
  class StreamingCacheContext : public Cache<TIdentifier, TComparer>::Context {

    /// <summary>Size of the buffer used to decompress the file</summary>
    public: static const std::size_t DecompressionBufferSize = 8192;

    /// <summary>When the buffer gets below this size, it is refilled</summary>
    /// <remarks>
    ///   The remaining buffer contents need to be copied to the front of the buffer,
    ///   so making this too large will cause needless copying of memory blocks.
    /// </remarks>
    public: static const std::size_t BufferRefillSize = 64;

    /// <summary>Initializes a new steaming context</summary>
    /// <param name="identifier">Identifier of the file the context is handling</param>
    /// <param name="blob">Blob the input data is coming from</param>
    public: StreamingCacheContext(
      const TIdentifier &identifier,
      const std::shared_ptr<Blob> &blob,
      std::uint64_t compressedDataStartOffset,
      std::uint64_t compressedDataLength
    ) :
      Context(identifier),
      blob(blob),
      compressedLocation(compressedDataStartOffset),
      compressedRemaining(compressedDataLength) {

      // Pre-allocate the memory of the buffers used to hold compressed and uncompressed data.
      // Vectors will never shrink, thus, this guarantees that no additional memory allocations
      // will happen during extraction.
      this->CompressedData.reserve(DecompressionBufferSize);
      this->UncompressedData.reserve(DecompressionBufferSize);
    }

    /// <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: void ReadAt(std::uint64_t location, void *buffer, std::size_t count) {
      using namespace std;
      assert((location >= this->Location) && "Cache can be advanced in forward direction only");

      // Determine the offset the requested data has as seen from our current buffer.
      // This may be way beyond the buffer capacity, in which case we need to seek
      std::uint64_t bufferStartOffset = location - this->Location;

      // If the requested data is past the end of the data we have buffered currently,
      // skip ahead until we reach the desired area.
      if(bufferStartOffset > this->UncompressedData.size()) {
        SkipTo(location);
        bufferStartOffset = location - this->Location;
      }

      std::uint8_t *indexableBuffer = reinterpret_cast<std::uint8_t *>(buffer);

      // Copy any data the caller is interested in out of the current buffer. The buffer start
      // offset is guaranteed to fit within a normal size_t now.
      std::size_t bufferCount = std::min(
        this->UncompressedData.size() - static_cast<std::size_t>(bufferStartOffset), count
      );
      if(bufferCount > 0) {
        std::copy_n(
          &this->UncompressedData[static_cast<std::size_t>(bufferStartOffset)], bufferCount,
          indexableBuffer
        );

        // If this was all the data the caller wanted, we can exit early.
        if(bufferCount == count) {
          return;
        }

        // Advance the pointers and counters in accordance with the part of the buffer we have
        // already processed above
        indexableBuffer += bufferCount;
        count -= bufferCount;
        location += bufferCount;
      }

      // If the amount of data requested is more than the decompression buffer can hold,
      // there's no point in hitting the decompression buffer at all and we can directly
      // extract the decompressed data into the caller-provided buffer.
      if(count > DecompressionBufferSize) {
        count = ExtractDirectly(indexableBuffer, count);
        if(count > 0 ){
          ExtractUsingBuffer(indexableBuffer, count);
        }
      } else {
        ExtractUsingBuffer(indexableBuffer, count);
      }

      //if(this->Location + this->UncompressedData.size() == uncompressedLength) {
      //  ReleaseCompressedData();
      //}
    }

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

    /// <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>
    /// <paraXm name="count">Number of bytes the caller wants to read</param>
    /// <returns>The number of bytes remaining to be extracted</returns>
    protected: virtual std::size_t ExtractDirectly(
      std::uint8_t *indexableBuffer, std::size_t count
    ) = 0;

    /// <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>
    protected: virtual void ExtractUsingBuffer(
      std::uint8_t *indexableBuffer, std::size_t count
    ) = 0;

    /// <summary>
    ///   Frees the memory used for decompression after stream has been decompressed
    /// </summary>
    /// <remarks>
    ///   Because decompressors can only advance in forward direction, after a decompressor
    ///   has fini
    /// </remarks>
    protected: virtual void ReleaseCompressedData() {
      this->CompressedData.resize(0);
      this->CompressedData.shrink_to_fit();
    }

    /// <summary>Refills the input-buffer, taking over the remaining data, if any</summary>
    /// <param name="remainingInputLength">
    ///   Amount of data still remaining in the input buffer (assumed to be at
    ///   the very end of the bfufer
    /// </param>
    protected: void RefillInputBuffer(std::size_t remainingInputLength = 0) {

      // First, move the remaining buffer contents to the start of the buffer so the new data
      // can be appended after it (a ring buffer would be cooler, but ZLib expects linear memory)
      if(remainingInputLength > 0) {
        std::size_t dataStartOffset = this->CompressedData.size() - remainingInputLength;

        // Make sure that the memory regions don't overlap (otherwise we'd have to use
        // std::copy_backward and pay with some performance, which we don't want to).
        {
          using namespace std;
          assert(
            (remainingInputLength < dataStartOffset) &&
            "RefillInputBuffer cannot be used until the buffer is at least half empty"
          );
        }
        std::copy_n(
          &this->CompressedData[dataStartOffset], remainingInputLength,
          &this->CompressedData[0]
        );
      }

      // Find out how many bytes the buffer can be refilled with. Usually, the buffer is
      // refilled to capacity, but near the end of the compressed data blob, it may be less.
      std::size_t bytesToCopy = this->CompressedData.capacity() - remainingInputLength;
      if(bytesToCopy > this->compressedRemaining) {
        bytesToCopy = static_cast<std::size_t>(this->compressedRemaining);
      }

      // Resize the buffer to the exact amount of data we're putting in it, then append
      // the data right after the leftover bits we moved to the beginning of the buffer.
      this->CompressedData.resize(bytesToCopy + remainingInputLength);
      this->blob->ReadAt(
        this->compressedLocation,
        &this->CompressedData[remainingInputLength],
        bytesToCopy
      );
      this->compressedLocation += bytesToCopy;
      this->compressedRemaining -= bytesToCopy;

    }

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

    /// <summary>Blob the context is caching data for</summary>
    private: std::shared_ptr<Blob> blob;
    /// <summary>Contains the compressed data</summary>
    protected: std::vector<std::uint8_t> CompressedData;
    /// <summary>Contains the uncompressed data</summary>
    protected: 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;

  };

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

}}} // namespace Nuclex::Storage::Helpers

#endif // NUCLEX_STORAGE_HELPERS_STREAMINGCACHECONTEXT_H