/*  -*- c++ -*-
    SPDX-FileCopyrightText: 2002 Marc Mutz <mutz@kde.org>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/
/**
  @file
  This file is part of the API for handling @ref MIME data and
  defines a @ref uuencode @ref Codec class.

  @brief
  Defines the UUCodec class.

  @authors Marc Mutz \<mutz@kde.org\>
*/

#include "kcodecsuuencode.h"

#include <QDebug>

#include <cassert>

using namespace KCodecs;

namespace KCodecs
{
class UUDecoder : public Decoder
{
    uint mStepNo;
    uchar mAnnouncedOctetCount; // (on current line)
    uchar mCurrentOctetCount; // (on current line)
    uchar mOutbits;
    bool mLastWasCRLF : 1;
    bool mSawBegin : 1; // whether we already saw ^begin...
    uint mIntoBeginLine : 3; // count #chars we compared against "begin" 0..5
    bool mSawEnd : 1; // whether we already saw ^end...
    uint mIntoEndLine : 2; // count #chars we compared against "end" 0..3

    void searchForBegin(const char *&scursor, const char *const send);

protected:
    friend class UUCodec;
    UUDecoder(Codec::NewlineType newline = Codec::NewlineLF)
        : Decoder(newline)
        , mStepNo(0)
        , mAnnouncedOctetCount(0)
        , mCurrentOctetCount(0)
        , mOutbits(0)
        , mLastWasCRLF(true)
        , mSawBegin(false)
        , mIntoBeginLine(0)
        , mSawEnd(false)
        , mIntoEndLine(0)
    {
    }

public:
    ~UUDecoder() override
    {
    }

    bool decode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend) override;
    // ### really needs no finishing???
    bool finish(char *&dcursor, const char *const dend) override
    {
        Q_UNUSED(dcursor);
        Q_UNUSED(dend);
        return true;
    }
};

Encoder *UUCodec::makeEncoder(NewlineType newline) const
{
    Q_UNUSED(newline)
    return nullptr; // encoding not supported
}

Decoder *UUCodec::makeDecoder(NewlineType newline) const
{
    return new UUDecoder(newline);
}

/********************************************************/
/********************************************************/
/********************************************************/

void UUDecoder::searchForBegin(const char *&scursor, const char *const send)
{
    static const char begin[] = "begin\n";
    static const uint beginLength = 5; // sic!

    assert(!mSawBegin || mIntoBeginLine > 0);

    while (scursor != send) {
        uchar ch = *scursor++;
        if (ch == begin[mIntoBeginLine]) {
            if (mIntoBeginLine < beginLength) {
                // found another char
                ++mIntoBeginLine;
                if (mIntoBeginLine == beginLength) {
                    mSawBegin = true; // "begin" complete, now search the next \n...
                }
            } else { // mIntoBeginLine == beginLength
                // found '\n': begin line complete
                mLastWasCRLF = true;
                mIntoBeginLine = 0;
                return;
            }
        } else if (mSawBegin) {
            // OK, skip stuff until the next \n
        } else {
            // qWarning() << "UUDecoder: garbage before \"begin\", resetting parser";
            mIntoBeginLine = 0;
        }
    }
}

// uuencoding just shifts all 6-bit octets by 32 (SP/' '), except NUL,
// which gets mapped to 0x60
static inline uchar uuDecode(uchar c)
{
    return (c - ' ') // undo shift and
        & 0x3F; // map 0x40 (0x60-' ') to 0...
}

bool UUDecoder::decode(const char *&scursor, const char *const send, char *&dcursor, const char *const dend)
{
    // First, check whether we still need to find the "begin" line:
    if (!mSawBegin || mIntoBeginLine != 0) {
        searchForBegin(scursor, send);
    } else if (mSawEnd) {
        // or if we are past the end line:
        scursor = send; // do nothing anymore...
        return true;
    }

    while (dcursor != dend && scursor != send) {
        uchar ch = *scursor++;
        uchar value;

        // Check whether we need to look for the "end" line:
        if (mIntoEndLine > 0) {
            static const char end[] = "end";
            static const uint endLength = 3;

            if (ch == end[mIntoEndLine]) {
                ++mIntoEndLine;
                if (mIntoEndLine == endLength) {
                    mSawEnd = true;
                    scursor = send; // shortcut to the end
                    return true;
                }
                continue;
            } else {
                // qWarning() << "UUDecoder: invalid line octet count looks like \"end\" (mIntoEndLine ="
                //           << mIntoEndLine << ")!";
                mIntoEndLine = 0;
                // fall through...
            }
        }

        // Normal parsing:

        // The first char of a line is an encoding of the length of the
        // current line. We simply ignore it:
        if (mLastWasCRLF) {
            // reset char-per-line counter:
            mLastWasCRLF = false;
            mCurrentOctetCount = 0;

            // try to decode the chars-on-this-line announcement:
            if (ch == 'e') { // maybe the beginning of the "end"? ;-)
                mIntoEndLine = 1;
            } else if (ch > 0x60) {
                // ### invalid line length char: what shall we do??
            } else if (ch > ' ') {
                mAnnouncedOctetCount = uuDecode(ch);
            } else if (ch == '\n') {
                mLastWasCRLF = true; // oops, empty line
            }

            continue;
        }

        // try converting ch to a 6-bit value:
        if (ch > 0x60) {
            continue; // invalid char
        } else if (ch > ' ') {
            value = uuDecode(ch);
        } else if (ch == '\n') { // line end
            mLastWasCRLF = true;
            continue;
        } else {
            continue;
        }

        // add the new bits to the output stream and flush full octets:
        switch (mStepNo) {
        case 0:
            mOutbits = value << 2;
            break;
        case 1:
            if (mCurrentOctetCount < mAnnouncedOctetCount) {
                *dcursor++ = (char)(mOutbits | value >> 4);
            }
            ++mCurrentOctetCount;
            mOutbits = value << 4;
            break;
        case 2:
            if (mCurrentOctetCount < mAnnouncedOctetCount) {
                *dcursor++ = (char)(mOutbits | value >> 2);
            }
            ++mCurrentOctetCount;
            mOutbits = value << 6;
            break;
        case 3:
            if (mCurrentOctetCount < mAnnouncedOctetCount) {
                *dcursor++ = (char)(mOutbits | value);
            }
            ++mCurrentOctetCount;
            mOutbits = 0;
            break;
        default:
            assert(0);
        }
        mStepNo = (mStepNo + 1) % 4;

        // check whether we ran over the announced octet count for this line:
        if (mCurrentOctetCount == mAnnouncedOctetCount + 1) {
            // qWarning()
            //         << "UUDecoder: mismatch between announced ("
            //         << mAnnouncedOctetCount << ") and actual line octet count!";
        }
    }

    // return false when caller should call us again:
    return scursor == send;
} // UUDecoder::decode()

} // namespace KCodecs