/*
 * Copyright (C) 2004, 2005, 2015 Filip Pizlo. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY FILIP PIZLO ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL FILIP PIZLO OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "tsf_internal.h"
#include "tsf_format.h"

#ifdef HAVE_ZLIB
#include <zlib.h>
#endif

#ifdef HAVE_BZIP2
#include <bzlib.h>
#endif

#define Cz(reader) ((z_stream*)((reader)->stream))
#define Cbz(reader) ((bz_stream*)((reader)->stream))

tsf_zip_rdr_t *tsf_zip_reader_create(tsf_partial_reader_t reader,
                                     void *reader_arg,
                                     tsf_zip_mode_t mode,
                                     const tsf_zip_rdr_attr_t *attr) {
    int res;
    tsf_zip_rdr_t *result=malloc(sizeof(tsf_zip_rdr_t));
    if (result==NULL) {
        tsf_set_errno("Could not malloc tsf_zip_rdr_t");
        return NULL;
    }
    
    result->decomp_eof=tsf_false;
    
    result->reader=reader;
    result->reader_arg=reader_arg;
    
    result->mode=mode;
    
    switch (mode) {
        case TSF_ZIP_ZLIB:
            result->buf_size=attr->z.buf_size;
            break;
        case TSF_ZIP_BZIP2:
            result->buf_size=attr->b.buf_size;
            break;
        case TSF_ZIP_NONE:
            tsf_set_error(TSF_E_INVALID_ARG,
                          "TSF_ZIP_NONE is not a valid mode for "
                          "tsf_zip_reader_create()");
            goto failure_1;
        default:
            tsf_set_error(TSF_E_INVALID_ARG,
                          "%d is not a valid mode number for "
                          "tsf_zip_reader_create()",mode);
            goto failure_1;
    }
    
    result->buf=malloc(result->buf_size);
    if (result->buf==NULL) {
        tsf_set_errno("Could not malloc buffer");
        goto failure_1;
    }
    
    result->abstract.next_in=result->buf;
    result->abstract.avail_in=0;
    
    switch (mode) {
        case TSF_ZIP_ZLIB:
#ifdef HAVE_ZLIB
            result->stream=malloc(sizeof(z_stream));
            if (result->stream==NULL) {
                tsf_set_errno("Could not malloc z_stream");
                goto failure_2;
            }
            
            Cz(result)->zalloc=NULL;
            Cz(result)->zfree=NULL;
            Cz(result)->opaque=NULL;
            
            if (attr->z.advanced_init) {
                res=inflateInit2(Cz(result),
                                 attr->z.windowBits);
            } else {
                res=inflateInit(Cz(result));
            }
            if (res!=Z_OK) {
                tsf_set_zlib_error(res,Cz(result)->msg,
                    "Trying to initialize inflation in ZLib");
                free(Cz(result));
                goto failure_2;
            }
            break;
#else
            tsf_set_error(TSF_E_NOT_SUPPORTED,
                          "TSF_ZIP_ZLIB is not supported by "
                          "tsf_zip_reader_create() because ZLib support "
                          "was not configured into the TSF library");
            goto failure_2;
#endif
        case TSF_ZIP_BZIP2:
#ifdef HAVE_BZIP2
            result->stream=malloc(sizeof(bz_stream));
            if (result->stream==NULL) {
                tsf_set_errno("Could not malloc bz_stream");
                goto failure_2;
            }
            
            Cbz(result)->bzalloc=NULL;
            Cbz(result)->bzfree=NULL;
            Cbz(result)->opaque=NULL;
            
            res=BZ2_bzDecompressInit(Cbz(result),
                                     attr->b.verbosity,
                                     attr->b.small);
            if (res!=BZ_OK) {
                tsf_set_libbzip2_error(res,
                    "Trying to initialize decompression in libbzip2");
                free(Cbz(result));
                goto failure_2;
            }
            
            break;
#else
            tsf_set_error(TSF_E_NOT_SUPPORTED,
                          "TSF_ZIP_BZIP2 is not supported by "
                          "tsf_zip_reader_create() because libbzip2 "
                          "support was not configured into the TSF "
                          "library");
            goto failure_2;
#endif
        default:
            tsf_abort("should've already caught this case");
            break;
    }
    
    return result;
    
failure_2:
    free(result->buf);
failure_1:
    free(result);
    return NULL;
}

void tsf_zip_reader_destroy(tsf_zip_rdr_t *reader) {
    switch (reader->mode) {
#ifdef HAVE_ZLIB
        case TSF_ZIP_ZLIB:
            inflateEnd(Cz(reader));
            break;
#endif
#ifdef HAVE_BZIP2
        case TSF_ZIP_BZIP2:
            BZ2_bzDecompressEnd(Cbz(reader));
            break;
#endif
        default:
            tsf_abort("unknown zip reader mode");
            break;
    }
    free(reader->stream);
    free(reader->buf);
    free(reader);
}

tsf_bool_t tsf_zip_reader_read(void *_reader,
                               void *data,
                               uint32_t len) {
    tsf_zip_rdr_t *reader = _reader;
    int32_t reader_res;
    tsf_zip_result_t zip_res;
    
    if (len == 0) {
        return tsf_true;
    }
    
    if (reader->decomp_eof) {
        reader_res = reader->reader(reader->reader_arg,
                                    reader->buf, 1);
        tsf_assert(reader_res == -1 || reader_res == 1);
        if (reader_res == 1) {
            tsf_set_error(TSF_E_NO_EOF,
                          "Expected EOF (because the "
                          "decompressor reached its end "
                          "of stream), but did not get "
                          "one (I was still able to read a byte)");
        }
        return tsf_false;
    }
    
    reader->abstract.next_out = data;
    reader->abstract.avail_out = len;
    
    for (;;) {
	/* is there ever a case where we would want to call inflate even though
	   the input buffer is empty? */
        if (reader->abstract.avail_in != 0) {
            zip_res = tsf_zip_abstract_inflate(reader->mode,
                                               reader->stream,
                                               &(reader->abstract),
                                               TSF_ZIP_ACT_RUN);
            
            if (zip_res == TSF_ZIP_RES_ERROR) {
                return tsf_false;
            } else if (zip_res == TSF_ZIP_RES_END) {
                if (reader->abstract.avail_in != 0) {
                    tsf_set_error(TSF_E_NO_EOF,
                                  "Expected EOF (because the "
                                  "decompressor reached its end "
                                  "of stream), but did not get "
                                  "one (there was still data left "
                                  "in the buffer)");
                    return tsf_false;
                }
                reader->decomp_eof = tsf_true;
                if (reader->abstract.avail_out == 0) {
                    break;
                }
                tsf_set_error((void*)reader->abstract.next_out == data ?
                              TSF_E_UNEXPECTED_EOF : TSF_E_ERRONEOUS_EOF,
                              NULL);
                return tsf_false;
            }
            
            if (reader->abstract.avail_out == 0) {
                break;
            }
            
            tsf_assert(reader->abstract.avail_in == 0);
        }
        
        reader_res = reader->reader(reader->reader_arg,
                                    reader->buf,
                                    reader->buf_size);
        
        if (reader_res == -1) {
            if (tsf_get_error_code() == TSF_E_UNEXPECTED_EOF) {
                tsf_set_error(TSF_E_ERRONEOUS_EOF,
                              "Got an EOF from the reader before the "
                              "decompressor had reached end of stream");
            }
            return tsf_false;
        }
        
        reader->abstract.next_in = reader->buf;
        reader->abstract.avail_in = reader_res;
    }
    
    return tsf_true;
}