/* Copyright (C) 2017 J.F.Dockes

 *   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 2 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, write to the

 *   Free Software Foundation, Inc.,

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

#include "zlibut.h"

#include <zlib.h>

#include "log.h"

using namespace std;

static void *allocmem(

    void *cp,    /* The array to grow. may be NULL */

    int  sz,     /* Unit size in bytes */

    int  *np,    /* Pointer to current allocation number */

    int  min,    /* Number to allocate the first time */

    int  maxinc) /* Maximum increment */

{

    if (cp == 0) {

        cp = malloc(min * sz);

        *np = cp ? min : 0;

        return cp;

    }

    int inc = (*np > maxinc) ?  maxinc : *np;

    if ((cp = realloc(cp, (*np + inc) * sz)) != 0) {

        *np += inc;

    }

    return cp;

}

class ZLibUtBuf::Internal {

public:

    Internal() {}

    ~Internal() {

        if (buf && dofree) {

            free(buf);

        }

    }

    bool grow(size_t n) {

        if (!initsz)

            initsz = n;

        buf = (char *)allocmem(buf, initsz, &alloc, 1, 20);

        return nullptr != buf;

    }

    int getAlloc() {

        return alloc * initsz;

    }

    char *buf{nullptr};

    int initsz{0}; // Set to first alloc size

    int alloc{0}; // Allocation count (allocmem()). Capa is alloc*inisz

    int datacnt{0}; // Data count

    bool dofree{true}; // Does buffer belong to me ?

    friend bool inflateToBuf(void* inp, unsigned int inlen, ZLibUtBuf& buf);

};

ZLibUtBuf::ZLibUtBuf()

{

    m = new Internal;

}

ZLibUtBuf::~ZLibUtBuf()

{

    delete m;

}

char *ZLibUtBuf::getBuf() const

{

    return m->buf;

}            

char *ZLibUtBuf::takeBuf()

{

    m->dofree = false;

    return m->buf;

}

size_t ZLibUtBuf::getCnt()

{

    return m->datacnt;

}

bool inflateToBuf(const void* inp, unsigned int inlen, ZLibUtBuf& buf)

{

    LOGDEB0("inflateToBuf: inlen " << inlen << "\n");

    z_stream d_stream; /* decompression stream */

    d_stream.zalloc = (alloc_func)0;

    d_stream.zfree = (free_func)0;

    d_stream.opaque = (voidpf)0;

    d_stream.next_in  = (Bytef*)inp;

    d_stream.avail_in = inlen;

    d_stream.next_out = 0;

    d_stream.avail_out = 0;

    int err;

    if ((err = inflateInit(&d_stream)) != Z_OK) {

        LOGERR("Inflate: inflateInit: err " << err << " msg "  <<

               d_stream.msg << "\n");

        return false;

    }

    for (;;) {

        LOGDEB2("InflateToDynBuf: avail_in " << d_stream.avail_in <<

                " total_in " << d_stream.total_in << " avail_out " <<

                d_stream.avail_out << " total_out " << d_stream.total_out <<

                "\n");

        if (d_stream.avail_out == 0) {

            if (!buf.m->grow(inlen)) {

                LOGERR("Inflate: out of memory, current alloc " <<

                       buf.m->getAlloc() << "\n");

                inflateEnd(&d_stream);

                return false;

            }

            d_stream.avail_out = buf.m->getAlloc() - d_stream.total_out;

            d_stream.next_out = (Bytef*)(buf.getBuf() + d_stream.total_out);

        }

        err = inflate(&d_stream, Z_NO_FLUSH);

        if (err == Z_STREAM_END) {

            break;

        }

        if (err != Z_OK) {

            LOGERR("Inflate: error " << err << " msg " <<

                   (d_stream.msg ? d_stream.msg : "") << endl);

            inflateEnd(&d_stream);

            return false;

        }

    }

    if ((err = inflateEnd(&d_stream)) != Z_OK) {

        LOGERR("Inflate: inflateEnd error " << err << " msg " <<

               (d_stream.msg ? d_stream.msg : "") << endl);

        return false;

    }

    buf.m->datacnt = d_stream.total_out;

    LOGDEB1("inflateToBuf: ok, output size " << buf.getCnt() << endl);

    return true;

}

bool deflateToBuf(const void* inp, unsigned int inlen, ZLibUtBuf& buf)

{

    uLongf len = compressBound(static_cast<uLong>(inlen));

    // This needs cleanup: because the buffer is reused inside

    // e.g. circache, we want a minimum size in case the 1st doc size,

    // which sets the grow increment is small. It would be better to

    // let the user set a min size hint.

    if (len < 500 *1024)

        len = 500 * 1024;

    while (buf.m->getAlloc() < int(len)) {

        if (!buf.m->grow(len)) {

            LOGERR("deflateToBuf: can't get buffer for " << len << " bytes\n");

            return false;

        }

    }

    bool ret = compress((Bytef*)buf.getBuf(), &len, (Bytef*)inp,

                        static_cast<uLong>(inlen)) == Z_OK;

    buf.m->datacnt = len;

    return ret;

}