#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include "compress_util.h"

#define CHUNK 1024 

void zlib_decompress_data(unsigned char *data_chunk, size_t file_length, unsigned char **buff, size_t *sz) {
        int ret;
        unsigned int have;
        z_stream strm;
        // Adding one to zero here
        unsigned char out[CHUNK];
        unsigned char in[CHUNK];

        errno=0;
        FILE *data_stream = fmemopen(data_chunk, file_length, "r");
        FILE *of = open_memstream((char**)buff, sz);
        if(data_stream == NULL) {
                perror("F MEM OPEN");
        }

        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        strm.avail_in = 0;
        strm.next_in = Z_NULL;
        ret = inflateInit(&strm);
        if(ret != Z_OK) {
                return;
        }

        do {
                strm.avail_in = fread(in, 1, CHUNK, data_stream);
                if(ferror(data_stream)) {
                        (void)inflateEnd(&strm);
                        return;
                }
                if(strm.avail_in == 0) {
                        break;
                }
                strm.next_in = in;
        
                do {
                        strm.avail_out = CHUNK;
                        strm.next_out = out;
                        ret = inflate(&strm, Z_NO_FLUSH);
                        assert(ret != Z_STREAM_ERROR);
                        switch(ret) {
                                case Z_NEED_DICT:
                                        ret = Z_DATA_ERROR;
                                case Z_DATA_ERROR:
                                case Z_MEM_ERROR:
                                        (void)inflateEnd(&strm);
                                        printf("Error: %d\n", ret);
                                        printf("MSG: %s\n", (char*)strm.msg);
                                        return;
                        }
                        have = CHUNK - strm.avail_out;
                        fwrite(out, 1, have, of);
                } while(strm.avail_out == 0);
        } while(ret != Z_STREAM_END);

        (void)inflateEnd(&strm);

        fclose(data_stream);
        fclose(of);
}

void zlib_compress_data(unsigned char *data_chunk, size_t file_length, unsigned char **buff, size_t *sz) {
        int ret, flush;
        unsigned int have;
        z_stream strm;
        unsigned char in[CHUNK];
        unsigned char out[CHUNK];
        int level = 9;
        int method = Z_DEFLATED;
        int windowBits = 10;
        int memLevel = 9;
        //int strategy = Z_DEFAULT_STRATEGY;
        int strategy = Z_FILTERED;

        FILE *data_stream = fmemopen(data_chunk, file_length, "r");
        FILE *out_data_stream = NULL;
        out_data_stream = open_memstream((char**)buff, sz);

        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        ret = deflateInit2(&strm, level, method, windowBits, memLevel, strategy);
        if (ret != Z_OK) {
                return;
        }

        do {
                strm.avail_in = fread(in, 1, CHUNK, data_stream);
                if (ferror(data_stream)) {
                        (void)deflateEnd(&strm);
                        return;
                }
                flush = feof(data_stream) ? Z_FINISH : Z_NO_FLUSH;
                strm.next_in = in;

                do {
                        strm.avail_out = CHUNK;
                        strm.next_out = out;

                        ret = deflate(&strm, flush);
                        assert(ret != Z_STREAM_ERROR);
                        have = CHUNK - strm.avail_out;
                        if(fwrite(out, 1, have, out_data_stream) != have || ferror(out_data_stream)) {
                                (void)deflateEnd(&strm);
                                return;
                        }
                } while(strm.avail_out == 0);
                assert(strm.avail_in == 0);

        } while(flush != Z_FINISH);
        assert(ret == Z_STREAM_END);

        fclose(data_stream);
        fclose(out_data_stream);

        (void)deflateEnd(&strm);
}