#include <qpdf/Pl_ASCII85Decoder.hh>

#include <qpdf/QTC.hh>

#include <qpdf/Util.hh>

#include <cstring>

#include <stdexcept>

using namespace qpdf;

Pl_ASCII85Decoder::Pl_ASCII85Decoder(char const* identifier, Pipeline* next) :

    Pipeline(identifier, next)

{

    util::assertion(next, "Attempt to create Pl_ASCII85Decoder with nullptr as next");

}

void

Pl_ASCII85Decoder::write(unsigned char const* buf, size_t len)

{

    if (eod > 1) {

        return;

    }

    for (size_t i = 0; i < len; ++i) {

        switch (buf[i]) {

        case ' ':

        case '\f':

        case '\v':

        case '\t':

        case '\r':

        case '\n':

            QTC::TC("libtests", "Pl_ASCII85Decoder ignore space");

            // ignore whitespace

            continue;

        }

        if (eod > 1) {

            break;

        } else if (eod == 1) {

            util::no_ci_rt_error_if(buf[i] != '>', "broken end-of-data sequence in base 85 data");

            flush();

            eod = 2;

        } else {

            switch (buf[i]) {

            case '~':

                eod = 1;

                break;

            case 'z':

                if (pos != 0) {

                    throw std::runtime_error("unexpected z during base 85 decode");

                }

                unsigned char zeroes[4];

                memset(zeroes, '\0', 4);

                next()->write(zeroes, 4);

                break;

            default:

                if (buf[i] < 33 || buf[i] > 117) {

                    error = true;

                    throw std::runtime_error("character out of range during base 85 decode");

                } else {

                    this->inbuf[this->pos++] = buf[i];

                    if (pos == 5) {

                        flush();

                    }

                }

                break;

            }

        }

    }

}

void

Pl_ASCII85Decoder::flush()

{

    if (this->pos == 0) {

        return;

    }

    unsigned long lval = 0;

    for (int i = 0; i < 5; ++i) {

        lval *= 85;

        lval += (this->inbuf[i] - 33U);

    }

    unsigned char outbuf[4];

    memset(outbuf, 0, 4);

    for (int i = 3; i >= 0; --i) {

        outbuf[i] = lval & 0xff;

        lval >>= 8;

    }

    QTC::TC("libtests", "Pl_ASCII85Decoder partial flush", (this->pos == 5) ? 0 : 1);

    // Reset before calling getNext()->write in case that throws an exception.

    auto t = this->pos - 1;

    this->pos = 0;

    memset(this->inbuf, 117, 5);

    next()->write(outbuf, t);

}

void

Pl_ASCII85Decoder::finish()

{

    if (error) {

        return;

    }

    flush();

    next()->finish();

}