/*
 * lftp - file transfer program
 *
 * Copyright (c) 1996-2016 by Alexander V. Lukyanov (lav@yars.free.net)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include "buffer_zlib.h"

void DataInflator::PutTranslated(Buffer *target,const char *put_buf,int size)
{
   bool from_untranslated=false;
   if(Size()>0)
   {
      Put(put_buf,size);
      Get(&put_buf,&size);
      from_untranslated=true;
   }
   // process all data we can, save the rest in the untranslated buffer
   while(size>0)
   {
      if(z_err==Z_STREAM_END)
      {
	 // assume the data after the compressed stream are not compressed.
	 target->Put(put_buf,size);
	 if(from_untranslated)
	    Skip(size);
	 return;
      }
      size_t put_size=size;
      int size_coeff=6;
      size_t store_size=size_coeff*put_size+256;
      char *store_buf=target->GetSpace(store_size);
      // do the inflation
      z.next_in=(Bytef*)put_buf;
      z.avail_in=put_size;
      z.next_out=(Bytef*)store_buf;
      z.avail_out=store_size;
      int ret = inflate(&z, Z_NO_FLUSH);
      switch (ret) {
      case Z_OK:
	 break;
      case Z_STREAM_END:
	 z_err=ret;
	 PutEOF();
	 break;
      case Z_NEED_DICT:
	 ret = Z_DATA_ERROR;
	 if(!z.msg)
	    z.msg=const_cast<char*>("missing dictionary");
	 /* fallthrough */
      default:
	 z_err=ret;
	 target->SetError(xstring::cat("zlib inflate error: ",z.msg,NULL),true);
	 return;
      }
      int inflated_size=store_size-z.avail_out;
      int processed_size=put_size-z.avail_in;

      target->SpaceAdd(inflated_size);
      if(from_untranslated) {
	 Skip(processed_size);
	 Get(&put_buf,&size);
      } else {
	 put_buf+=processed_size;
	 size-=processed_size;
      }
      if(inflated_size==0) {
	 // could not inflate any data, save unprocessed data
	 if(!from_untranslated)
	    Put(put_buf,size);
	 return;
      }
   }
}

DataInflator::DataInflator()
{
   /* allocate inflate state */
   memset(&z,0,sizeof(z));
   z_err = inflateInit2(&z, 32+MAX_WBITS);
}
DataInflator::~DataInflator()
{
   (void)inflateEnd(&z);
}
void DataInflator::ResetTranslation()
{
   z_err = inflateReset(&z);
}


void DataDeflator::PutTranslated(Buffer *target,const char *put_buf,int size)
{
   const int flush=(put_buf?Z_NO_FLUSH:Z_FINISH);
   bool from_untranslated=false;
   if(Size()>0)
   {
      Put(put_buf,size);
      Get(&put_buf,&size);
      from_untranslated=true;
   }
   int size_coeff=1;
   // process all data we can, save the rest in the untranslated buffer
   while(size>0 || flush==Z_FINISH)
   {
      size_t put_size=size;
      size_t store_size=size_coeff*put_size+256;
      char *store_buf=target->GetSpace(store_size);
      // do the deflation
      z.next_in=(Bytef*)put_buf;
      z.avail_in=put_size;
      z.next_out=(Bytef*)store_buf;
      z.avail_out=store_size;
      int ret = deflate(&z,flush);
      switch (ret) {
      case Z_OK:
	 break;
      case Z_BUF_ERROR:
	 size_coeff*=2;
	 continue;
      case Z_STREAM_END:
	 z_err=ret;
	 break;
      default:
	 z_err=ret;
	 target->SetError(xstring::cat("zlib deflate error: ",z.msg,NULL),true);
	 return;
      }
      int deflated_size=store_size-z.avail_out;
      int processed_size=put_size-z.avail_in;

      target->SpaceAdd(deflated_size);
      if(from_untranslated) {
	 Skip(processed_size);
	 Get(&put_buf,&size);
      } else {
	 put_buf+=processed_size;
	 size-=processed_size;
      }
      if(deflated_size==0) {
	 // could not deflate any data, save unprocessed data
	 if(!from_untranslated)
	    Put(put_buf,size);
	 return;
      }
      if(flush==Z_FINISH && ret==Z_STREAM_END)
	 break;
   }
}

DataDeflator::DataDeflator(int level)
{
   /* allocate deflate state */
   memset(&z,0,sizeof(z));
   z_err = deflateInit(&z, level);
}
DataDeflator::~DataDeflator()
{
   (void)deflateEnd(&z);
}
void DataDeflator::ResetTranslation()
{
   z_err = deflateReset(&z);
}