/*
 *
 *  Copyright (C) 2002-2010, OFFIS e.V.
 *  All rights reserved.  See COPYRIGHT file for details.
 *
 *  This software and supporting documentation were developed by
 *
 *    OFFIS e.V.
 *    R&D Division Health
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *
 *  Module:  dcmdata
 *
 *  Author:  Marco Eichelberg
 *
 *  Purpose: zlib compression filter for output streams
 *
 */

#include "dcmtk/config/osconfig.h"

#ifdef WITH_ZLIB

#include "dcmtk/dcmdata/dcostrmz.h"
#include "dcmtk/dcmdata/dcerror.h"

#define DCMZLIBOUTPUTFILTER_BUFSIZE 4096

/* taken from zutil.h */
#if MAX_MEM_LEVEL >= 8
#define DEF_MEM_LEVEL 8
#else
#define DEF_MEM_LEVEL  MAX_MEM_LEVEL
#endif

OFGlobal<int> dcmZlibCompressionLevel(Z_DEFAULT_COMPRESSION);

// helper method to fix old-style casts warnings
BEGIN_EXTERN_C
static int OFdeflateInit(z_stream* const stream, int level)
{
#ifdef ZLIB_ENCODE_RFC1950_HEADER
  /* create deflated ZLIB format instead of deflated bitstream format
   * (i.e. RFC 1950 instead of RFC 1951).
   * THE RESULTING BITSTREAM IS NOT DICOM COMPLIANT!
   * Use only for testing, and use with care.
   */
  return deflateInit(stream, level);
#else
  /* windowBits is passed < 0 to suppress zlib header */
  return deflateInit2(stream, level, Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
#endif
}
END_EXTERN_C

DcmZLibOutputFilter::DcmZLibOutputFilter()
: DcmOutputFilter()
, current_(NULL)
, zstream_(new z_stream)
, status_(EC_MemoryExhausted)
, flushed_(OFFalse)
, inputBuf_(new unsigned char[DCMZLIBOUTPUTFILTER_BUFSIZE])
, inputBufStart_(0)
, inputBufCount_(0)
, outputBuf_(new unsigned char[DCMZLIBOUTPUTFILTER_BUFSIZE])
, outputBufStart_(0)
, outputBufCount_(0)
{
  if (zstream_ && inputBuf_ && outputBuf_)
  {
    zstream_->zalloc = Z_NULL;
    zstream_->zfree = Z_NULL;
    zstream_->opaque = Z_NULL;
    if (Z_OK == OFdeflateInit(zstream_, dcmZlibCompressionLevel.get()))
      status_ = EC_Normal;
    else
    {
      OFString etext = "ZLib Error: ";
      if (zstream_->msg) etext += zstream_->msg;
      status_ = makeOFCondition(OFM_dcmdata, 16, OF_error, etext.c_str());
    }
  }
}

DcmZLibOutputFilter::~DcmZLibOutputFilter()
{
  if (zstream_)
  {
    deflateEnd(zstream_); // discards any unprocessed input and does not flush any pending output
    delete zstream_;
  }
  delete[] inputBuf_;
  delete[] outputBuf_;
}


OFBool DcmZLibOutputFilter::good() const
{
  return status_.good();
}

OFCondition DcmZLibOutputFilter::status() const
{
  return status_;
}

OFBool DcmZLibOutputFilter::isFlushed() const
{
  if (status_.bad() || (current_ == NULL)) return OFTrue;
  return (inputBufCount_ == 0) && (outputBufCount_ == 0) && flushed_ && current_->isFlushed();
}


offile_off_t DcmZLibOutputFilter::avail() const
{
  // compute number of bytes available in input buffer
  if (status_.good() ) return DCMZLIBOUTPUTFILTER_BUFSIZE - inputBufCount_;
    else return 0;
}

void DcmZLibOutputFilter::flushOutputBuffer()
{
  if (outputBufCount_)
  {
    // flush from outputBufStart_ to end of data or end of buffer, whatever comes first
    offile_off_t numBytes = (outputBufStart_ + outputBufCount_ > DCMZLIBOUTPUTFILTER_BUFSIZE) ?
      (DCMZLIBOUTPUTFILTER_BUFSIZE - outputBufStart_) : outputBufCount_ ;

    offile_off_t written = current_->write(outputBuf_ + outputBufStart_, numBytes);

    // adjust counters
    outputBufCount_ -= written;
    outputBufStart_ += written;

    if (outputBufStart_ == DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      // wrapped around
      outputBufStart_ = 0;

      // now flush to end of data
      if (outputBufCount_ && written)
      {
        written = current_->write(outputBuf_, outputBufCount_);

        // adjust counters
        outputBufCount_ -= written;
        outputBufStart_ += written;
      }
    }

    // reset buffer start to make things faster
    if (outputBufCount_ == 0) outputBufStart_ = 0;
  }
}

offile_off_t DcmZLibOutputFilter::fillInputBuffer(const void *buf, offile_off_t buflen)
{
  offile_off_t result = 0;
  if (buf && buflen && inputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
  {

    const unsigned char *data = OFstatic_cast(const unsigned char *, buf);

    // use first part of input buffer
    if (inputBufStart_ + inputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      result = DCMZLIBOUTPUTFILTER_BUFSIZE - (inputBufStart_ + inputBufCount_);
      if (result > buflen) result = buflen;

      memcpy(inputBuf_ + inputBufStart_ + inputBufCount_, data, OFstatic_cast(size_t, result));
      inputBufCount_ += result;
      data += result;
      buflen -= result;
    }

    // use second part of input buffer
    if (buflen && (inputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE) &&
        inputBufStart_ + inputBufCount_ >= DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      offile_off_t len = DCMZLIBOUTPUTFILTER_BUFSIZE - inputBufCount_;
      if (len > buflen) len = buflen;

      memcpy(inputBuf_ + (inputBufStart_ + inputBufCount_ - DCMZLIBOUTPUTFILTER_BUFSIZE), data, OFstatic_cast(size_t, len));

      inputBufCount_ += len;
      result += len;
    }
  }
  return result;
}

void DcmZLibOutputFilter::compressInputBuffer(OFBool finalize)
{
  if (inputBufCount_ || finalize)
  {
    // flush from inputBufStart_ to end of data or end of buffer, whatever comes first
    offile_off_t numBytes = (inputBufStart_ + inputBufCount_ > DCMZLIBOUTPUTFILTER_BUFSIZE) ?
      (DCMZLIBOUTPUTFILTER_BUFSIZE - inputBufStart_) : inputBufCount_ ;

    offile_off_t written = compress(inputBuf_ + inputBufStart_, numBytes, finalize);

    // adjust counters
    inputBufCount_ -= written;
    inputBufStart_ += written;

    if (inputBufStart_ == DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      // wrapped around
      inputBufStart_ = 0;

      // now flush to end of data
      if (inputBufCount_ && written)
      {
        written = compress(inputBuf_, inputBufCount_, finalize);

        // adjust counters
        inputBufCount_ -= written;
        inputBufStart_ += written;
      }
    }

    // reset buffer start to make things faster
    if (inputBufCount_ == 0) inputBufStart_ = 0;
  }
}

offile_off_t DcmZLibOutputFilter::compress(const void *buf, offile_off_t buflen, OFBool finalize)
{
  offile_off_t result = 0;
  if (outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
  {
    zstream_->next_in = OFstatic_cast(Bytef *, OFconst_cast(void *, buf));
    zstream_->avail_in = OFstatic_cast(uInt, buflen);
    int zstatus;

    // use first part of output buffer
    if (outputBufStart_ + outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      zstream_->next_out = OFstatic_cast(Bytef *, outputBuf_ + outputBufStart_ + outputBufCount_);
      zstream_->avail_out = OFstatic_cast(uInt, DCMZLIBOUTPUTFILTER_BUFSIZE - (outputBufStart_ + outputBufCount_));
      zstatus = deflate(zstream_, (finalize ? Z_FINISH : 0));

      if (zstatus == Z_OK || zstatus == Z_BUF_ERROR) { /* everything OK */ }
      else if (zstatus == Z_STREAM_END) flushed_ = OFTrue;
      else
      {
        OFString etext = "ZLib Error: ";
        if (zstream_->msg) etext += zstream_->msg;
        status_ = makeOFCondition(OFM_dcmdata, 16, OF_error, etext.c_str());
      }

      outputBufCount_ = DCMZLIBOUTPUTFILTER_BUFSIZE - outputBufStart_ - OFstatic_cast(offile_off_t, zstream_->avail_out);
    }

    // use second part of output buffer
    if ((outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE) &&
        outputBufStart_ + outputBufCount_ >= DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      zstream_->next_out = OFstatic_cast(Bytef *, outputBuf_ + (outputBufStart_ + outputBufCount_ - DCMZLIBOUTPUTFILTER_BUFSIZE));
      zstream_->avail_out = OFstatic_cast(uInt, DCMZLIBOUTPUTFILTER_BUFSIZE - outputBufCount_);
      zstatus = deflate(zstream_, (finalize ? Z_FINISH : 0));

      if (zstatus == Z_OK || zstatus == Z_BUF_ERROR) { /* everything OK */ }
      else if (zstatus == Z_STREAM_END) flushed_ = OFTrue;
      else
      {
        OFString etext = "ZLib Error: ";
        if (zstream_->msg) etext += zstream_->msg;
        status_ = makeOFCondition(OFM_dcmdata, 16, OF_error, etext.c_str());
      }

      outputBufCount_ =  DCMZLIBOUTPUTFILTER_BUFSIZE - OFstatic_cast(offile_off_t, zstream_->avail_out);
    }

    result = (buflen - OFstatic_cast(offile_off_t, zstream_->avail_in));
  }
  return result;
}

offile_off_t DcmZLibOutputFilter::write(const void *buf, offile_off_t buflen)
{
  if (status_.bad() || (current_ == NULL)) return 0;

  // flush output buffer if necessary
  if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();

  // compress pending input from input buffer
  while (status_.good() && inputBufCount_ > 0 && outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
  {
    compressInputBuffer(OFFalse);
    if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();
  }

  const unsigned char *data = OFstatic_cast(const unsigned char *, buf);
  offile_off_t result = 0;

  // compress user data only if input buffer is empty
  if (inputBufCount_ == 0)
  {
    while (status_.good() && (buflen > result) && outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      result += compress(data+result, buflen-result, OFFalse);
      if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();
    }
  }

  // finally stuff as much into the input buffer as possible
  result += fillInputBuffer(data+result, buflen-result);

  // total number of bytes consumed from input
  return result;
}


void DcmZLibOutputFilter::flush()
{
  if (status_.good() && current_)
  {
    // flush output buffer first
    if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();

    // compress pending input from input buffer
    while (status_.good() && inputBufCount_ > 0 && outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      compressInputBuffer(OFTrue);
      if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();
    }

    while (status_.good() && (! flushed_) && outputBufCount_ < DCMZLIBOUTPUTFILTER_BUFSIZE)
    {
      // create output from compression engine until end of compressed stream
      compress(NULL, 0, OFTrue);
      if (outputBufCount_ == DCMZLIBOUTPUTFILTER_BUFSIZE) flushOutputBuffer();
    }

    // final attempt to flush output buffer
    if (outputBufCount_ > 0) flushOutputBuffer();
  }
}


void DcmZLibOutputFilter::append(DcmConsumer& consumer)
{
  current_ = &consumer;
}

#else  /* WITH_ZLIB */

/* make sure that the object file is not completely empty if compiled
 * without zlib because some linkers might fail otherwise.
 */
void dcostrmz_dummy_function()
{
  return;
}

#endif /* WITH_ZLIB */