#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_SEVENZIP_DECODER_MULTIDECODERCONTEXT_H
#define NUCLEX_STORAGE_FILESYSTEM_SEVENZIP_DECODER_MULTIDECODERCONTEXT_H

#include "Nuclex/Storage/Config.h"

#include "../SevenZipArchive.h"
#include "../../../Helpers/StreamingCacheContext.h"

#include "lzma/LzmaDec.h"

namespace Nuclex { namespace Storage { namespace FileSystem { namespace SevenZip {

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

  class StreamProcessor;

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

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

namespace Nuclex { namespace Storage { namespace FileSystem { namespace SevenZip {

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

  /// <summary>
  ///   Maintains the decompression states and buffers for multiple chained decoders
  /// </summary>
  /// <remarks>
  ///   <para>
  ///     Currently this context is designed to assume one main input stream (containing
  ///     the data to be decompressed) and any number of control streams that are extracted
  ///     in full upfront (as they might contain data needed for decompression of the main
  ///     stream - like dictionaries, seek offsets or compression settings).
  ///   </para>
  ///   <para>
  ///     This assumption works for all current 7-Zip compression methods. All but one
  ///     operate in a single stream and the one that does not - BCJ2 - still uses
  ///     one main stream, one control stream and two supplemental streams that could
  ///     perhaps be streamed, but in practice are so small that the overhead would likely
  ///     offset any gain.
  ///   </para>
  /// </remarks>
  class MultiDecoderContext : public Helpers::StreamingCacheContext<std::size_t> {

    // LZMA requires a certain input length or there's no guarantee it can extract
    // anything from the buffer (LZMA_REQUIRED_INPUT_MAX is the number of bytes the worst-case
    // atomic chunk of compressed data can be long).
    static_assert(
      (BufferRefillSize >= LZMA_REQUIRED_INPUT_MAX),
      "Low water mark for input buffer must be more than the minimum LZMA input length"
    );

    /// <summary>
    ///   Initializes a new context for decoding data with multiple filters and/or
    ///   decompressors chained together
    /// </summary>
    /// <param name="sevenZipArchive">Archive the decoder context will work on</param>
    /// <param name="solidBlockIndex">
    ///   Index of the solid block this context will decode
    /// </param>
    public: MultiDecoderContext(
      const std::shared_ptr<SevenZipArchive> &sevenZipArchive,
      std::size_t solidBlockIndex
    );

    /// <summary>Adds a stream processor through which data will be processed</summary>
    /// <param name="streamProcessor">
    ///   Stream processor that will be applied to data read from the context
    /// </param>
    public: void AddStreamProcessor(const std::shared_ptr<StreamProcessor> &streamProcessor);

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

    /// <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>
    protected: std::size_t ExtractDirectly(
      std::uint8_t *indexableBuffer, std::size_t count
    );

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

    /// <summary>7-zip archive the context is extracting</summary>
    private: std::shared_ptr<SevenZipArchive> sevenZipArchive;
    /// <summary>Current location within the compressed data</summary>
    private: std::size_t inputBufferLocation;
    /// <summary>Stream processors used by the reader to uncompress data</summary>
    private: std::vector< std::shared_ptr<StreamProcessor> > streamProcessors;
      
  };

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

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

#endif // NUCLEX_STORAGE_FILESYSTEM_SEVENZIP_DECODER_MULTIDECODERCONTEXT_H