AuroraRuntime/Source/Compression/Compressors/BZip2Compressor.hpp

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

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

#include "bzlib.h"

typedef struct
{
    void *    handle;
    char      buf[BZ_MAX_UNUSED];
    AuInt32   bufN;
    char      writing;
    bz_stream strm;
    AuInt32   lastErr;
    char      initialisedOk;
} bz2_file;

static const char *BShitToString(int error)
{
    int n {};
    bz2_file B;
    B.lastErr = error;
    return BZ2_bzerror((BZFILE *)&B, &n);
}

namespace Aurora::Compression
{
    struct BZIPDeflate : BaseStream
    {
        CompressInfo meta;

        BZIPDeflate(const CompressInfo &meta) : meta(meta), BaseStream(meta.uInternalStreamSize)
        {}

        ~BZIPDeflate()
        {
            if (this->bInit_)
            {
                BZ2_bzCompressEnd(&this->ctx_);
            }
        }

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

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

            auto ret = BZ2_bzCompressInit(&this->ctx_, meta.uCompressionLevel, 0, 0);
            if (ret < Z_OK)
            {
                SysPushErrorMem("Error: {}", BShitToString(ret));
                return false;
            }
            this->bInit_ = 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<char, 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_;

                    auto ret = BZ2_bzCompress(&this->ctx_, BZ_RUN);
                    if (ret < Z_OK)
                    {
                        SysPushErrorIO("Error: {}", BShitToString(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("Memory Error");
                        return AuMakePair(read, 0);
                    }

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

            return AuMakePair(read, done);
        }

        bool Flush() override
        {
            return RunFlush(BZ_FLUSH);
        }

        bool Finish() override
        {
            return RunFlush(BZ_FINISH);
        }

        bool RunFlush(int type)
        {
            if (!this->pReader_)
            {
                return {};
            }

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

                    auto ret = BZ2_bzCompress(&this->ctx_, type);
                    if (ret < Z_OK)
                    {
                        SysPushErrorIO("Error: {}", BShitToString(ret));
                        this->pReader_.reset();
                        return false;
                    }

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

                    if (!Write(reinterpret_cast<const AuUInt8*>(this->dout_),
                        have))
                    {
                        this->pReader_.reset();
                        SysPushErrorIO("Memory Error");
                        return false;
                    }

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

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

                    auto ret = BZ2_bzCompress(&this->ctx_, type);
                    if (ret < Z_OK)
                    {
                        SysPushErrorIO("Error: {}", BShitToString(ret));
                        this->pReader_.reset();
                        return false;
                    }

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

                    if (!Write(reinterpret_cast<const AuUInt8 *>(this->dout_),
                        have))
                    {
                        this->pReader_.reset();
                        SysPushErrorIO("Memory Error");
                        return false;
                    }

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

            return true;
        }

    private:
        AuSPtr<IO::IStreamReader> pReader_;
        bz_stream ctx_ {};
        bool bInit_ {};
        char dout_[kChunkSize];
        char din_[kChunkSize];
    };
}