/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: DeflateDecompressor.hpp
    Date: 2022-2-15
    Author: Reece
***/
#pragma once

#include "zlib.h"

namespace Aurora::Compression
{
    struct ZIPInflate : BaseStream
    {
        DecompressInfo meta;

        ZIPInflate(const DecompressInfo &meta, bool hasBits, AuInt8 bits) : meta(meta), BaseStream(meta.uInternalStreamSize), cBits_(bits), bHasBits_(hasBits)
        {}

        ~ZIPInflate()
        {
            if (this->init_)
            {
                inflateEnd(&this->ctx_);
            }
        }

        bool Init(const AuSPtr<IO::IStreamReader> &reader) override
        {
            int ret;
            this->pReader_ = reader;

            if (!this->IsValid())
            {
                SysPushErrorMem();
                return false;
            }

            if (this->bHasBits_)
            {
                ret = inflateInit2(&this->ctx_, this->cBits_);
            }
            else
            {
                ret = inflateInit(&this->ctx_);
            }

            if (ret < Z_OK)
            {
                SysPushErrorMem("Error: {}", zError(ret));
                return false;
            }
            this->init_ = true;

            this->SetArray(this->din_);
            return true;
        }

        AuStreamReadWrittenPair_t Ingest_s(AuUInt32 input) override
        {
            AuUInt32 done {}, read {};

            if (!this->pReader_)
            {
                return {};
            }

            while (read < input)
            {
                read += IngestForInPointer<Bytef, uInt>(this->pReader_, this->ctx_.next_in, this->ctx_.avail_in, input - read);

                if (!this->ctx_.avail_in)
                {
                    return {read, done};
                }

                do
                {
                    this->ctx_.avail_out = AuArraySize(this->dout_);
                    this->ctx_.next_out = this->dout_;

                    if (!this->ctx_.avail_out)
                    {
                        break;
                    }

                    auto ret = inflate(&this->ctx_, Z_NO_FLUSH);
                    if (ret < Z_OK)
                    {
                        SysPushErrorIO("Error: {}", zError(ret));
                        this->pReader_.reset();
                        return AuMakePair(read, 0);
                    }

                    auto have = AuArraySize(this->dout_) - this->ctx_.avail_out;
                    done += have;

                    if (!Write(reinterpret_cast<const AuUInt8 *>(this->dout_),
                        have))
                    {
                        this->pReader_.reset();
                        SysPushErrorIO("Compression Out of Overhead");
                        return AuMakePair(read, 0);
                    }

                }
                while (this->ctx_.avail_out == 0);
            }

            return {read, done};
        }

    private:
        AuSPtr<IO::IStreamReader> pReader_;
        z_stream ctx_ {};
        bool init_ {};
        bool bHasBits_;
        AuInt8 cBits_;
        unsigned char din_[kChunkSize];
        unsigned char dout_[kChunkSize];
    };
}