// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:critical reason:data-parser

#if 0
// keep existing syncqt header working after the move of the class
// into qstringconverter_base
#pragma qt_class(QStringConverter)
#endif

#ifndef QSTRINGCONVERTER_H
#define QSTRINGCONVERTER_H

#include <QtCore/qstringconverter_base.h>
#include <QtCore/qstring.h>
#include <QtCore/qstringbuilder.h>

QT_BEGIN_NAMESPACE

class QStringEncoder : public QStringConverter
{
protected:
    constexpr explicit QStringEncoder(const Interface *i) noexcept
        : QStringConverter(i)
    {}
public:
    constexpr QStringEncoder() noexcept
        : QStringConverter()
    {}
    constexpr explicit QStringEncoder(Encoding encoding, Flags flags = Flag::Default)
        : QStringConverter(encoding, flags)
    {}
    explicit QStringEncoder(QAnyStringView name, Flags flags = Flag::Default)
        : QStringConverter(name, flags)
    {}

    template<typename T>
    struct DecodedData
    {
        QStringEncoder *encoder;
        T data;
        operator QByteArray() const { return encoder->encodeAsByteArray(data); }
    };
    Q_WEAK_OVERLOAD
    DecodedData<const QString &> operator()(const QString &str)
    { return DecodedData<const QString &>{this, str}; }
    DecodedData<QStringView> operator()(QStringView in)
    { return DecodedData<QStringView>{this, in}; }
    Q_WEAK_OVERLOAD
    DecodedData<const QString &> encode(const QString &str)
    { return DecodedData<const QString &>{this, str}; }
    DecodedData<QStringView> encode(QStringView in)
    { return DecodedData<QStringView>{this, in}; }

    qsizetype requiredSpace(qsizetype inputLength) const
    { return iface ? iface->fromUtf16Len(inputLength) : 0; }
    char *appendToBuffer(char *out, QStringView in)
    {
        if (!iface) {
            state.invalidChars = 1;
            return out;
        }
        return iface->fromUtf16(out, in, &state);
    }

    using FinalizeResult = FinalizeResultChar<char>;
    [[nodiscard]] Q_CORE_EXPORT FinalizeResult finalize(char *out, qsizetype maxlen);
    [[nodiscard]] FinalizeResult finalize() { return finalize(nullptr, 0); }

private:
    QByteArray invalidateAndReturnNull()
    {
        // ensure that hasError returns true
        state.invalidChars = 1;
        return QByteArray();
    }
    QByteArray encodeAsByteArrayImpl(QStringView in)
    {
        QByteArray result(iface->fromUtf16Len(in.size()), Qt::Uninitialized);
        char *out = result.data();
        out = iface->fromUtf16(out, in, &state);
        result.truncate(out - result.constData());
        return result;
    }
    QByteArray encodeAsByteArray(QStringView in)
    {
        return iface ? encodeAsByteArrayImpl(in) : invalidateAndReturnNull();
    }
};

class QStringDecoder : public QStringConverter
{
protected:
    constexpr explicit QStringDecoder(const Interface *i) noexcept
        : QStringConverter(i)
    {}
public:
    constexpr explicit QStringDecoder(Encoding encoding, Flags flags = Flag::Default)
        : QStringConverter(encoding, flags)
    {}
    constexpr QStringDecoder() noexcept
        : QStringConverter()
    {}
    explicit QStringDecoder(QAnyStringView name, Flags f = Flag::Default)
        : QStringConverter(name, f)
    {}

    template<typename T>
    struct EncodedData
    {
        QStringDecoder *decoder;
        T data;
        operator QString() const { return decoder->decodeAsString(data); }
    };
    Q_WEAK_OVERLOAD
    EncodedData<const QByteArray &> operator()(const QByteArray &ba)
    { return EncodedData<const QByteArray &>{this, ba}; }
    EncodedData<QByteArrayView> operator()(QByteArrayView ba)
    { return EncodedData<QByteArrayView>{this, ba}; }
    Q_WEAK_OVERLOAD
    EncodedData<const QByteArray &> decode(const QByteArray &ba)
    { return EncodedData<const QByteArray &>{this, ba}; }
    EncodedData<QByteArrayView> decode(QByteArrayView ba)
    { return EncodedData<QByteArrayView>{this, ba}; }

    qsizetype requiredSpace(qsizetype inputLength) const
    { return iface ? iface->toUtf16Len(inputLength) : 0; }
    QChar *appendToBuffer(QChar *out, QByteArrayView ba)
    {
        if (!iface) {
            state.invalidChars = 1;
            return out;
        }
        return iface->toUtf16(out, ba, &state);
    }
    char16_t *appendToBuffer(char16_t *out, QByteArrayView ba)
    { return reinterpret_cast<char16_t *>(appendToBuffer(reinterpret_cast<QChar *>(out), ba)); }


    using FinalizeResult = FinalizeResultChar<char16_t>;
    using FinalizeResultQChar = FinalizeResultChar<QChar>;
    [[nodiscard]] FinalizeResultQChar finalize(QChar *out, qsizetype maxlen)
    {
        auto r = finalize(reinterpret_cast<char16_t *>(out), maxlen);
        return {reinterpret_cast<QChar *>(r.next), r.invalidChars, r.error};
    }
    [[nodiscard]] Q_CORE_EXPORT FinalizeResult finalize(char16_t *out, qsizetype maxlen);
    [[nodiscard]] FinalizeResult finalize()
    {
        return finalize(static_cast<char16_t *>(nullptr), 0);
    }

    Q_CORE_EXPORT static QStringDecoder decoderForHtml(QByteArrayView data);

private:
    QString invalidateAndReturnNull()
    {
        // ensure that hasError returns true
        state.invalidChars = 1;
        return QString();
    }
    QString decodeAsStringImpl(QByteArrayView in)
    {
        QString result(iface->toUtf16Len(in.size()), Qt::Uninitialized);
        const QChar *out = iface->toUtf16(result.data(), in, &state);
        result.truncate(out - result.constData());
        return result;
    }
    QString decodeAsString(QByteArrayView in)
    {
        return iface ? decodeAsStringImpl(in) : invalidateAndReturnNull();
    }
};


#if defined(QT_USE_FAST_OPERATOR_PLUS) || defined(QT_USE_QSTRINGBUILDER)
template <typename T>
struct QConcatenable<QStringDecoder::EncodedData<T>>
        : private QAbstractConcatenable
{
    typedef QChar type;
    typedef QString ConvertTo;
    enum { ExactSize = false };
    static qsizetype size(const QStringDecoder::EncodedData<T> &s) { return s.decoder->requiredSpace(s.data.size()); }
    static inline void appendTo(const QStringDecoder::EncodedData<T> &s, QChar *&out)
    {
        out = s.decoder->appendToBuffer(out, s.data);
    }
};

template <typename T>
struct QConcatenable<QStringEncoder::DecodedData<T>>
        : private QAbstractConcatenable
{
    typedef char type;
    typedef QByteArray ConvertTo;
    enum { ExactSize = false };
    static qsizetype size(const QStringEncoder::DecodedData<T> &s) { return s.encoder->requiredSpace(s.data.size()); }
    static inline void appendTo(const QStringEncoder::DecodedData<T> &s, char *&out)
    {
        out = s.encoder->appendToBuffer(out, s.data);
    }
};

template <typename T>
QString &operator+=(QString &a, const QStringDecoder::EncodedData<T> &b)
{
    qsizetype len = a.size() + QConcatenable<QStringDecoder::EncodedData<T>>::size(b);
    a.reserve(len);
    QChar *it = a.data() + a.size();
    QConcatenable<QStringDecoder::EncodedData<T>>::appendTo(b, it);
    a.resize(qsizetype(it - a.constData())); //may be smaller than len
    return a;
}

template <typename T>
QByteArray &operator+=(QByteArray &a, const QStringEncoder::DecodedData<T> &b)
{
    qsizetype len = a.size() + QConcatenable<QStringEncoder::DecodedData<T>>::size(b);
    a.reserve(len);
    char *it = a.data() + a.size();
    QConcatenable<QStringEncoder::DecodedData<T>>::appendTo(b, it);
    a.resize(qsizetype(it - a.constData())); //may be smaller than len
    return a;
}
#endif

template <typename InputIterator>
void QString::assign_helper_char8(InputIterator first, InputIterator last)
{
    static_assert(!QString::is_contiguous_iterator_v<InputIterator>,
        "Internal error: Should have been handed over to the QAnyStringView overload."
    );

    using ValueType = typename std::iterator_traits<InputIterator>::value_type;
    constexpr bool IsFwdIt = std::is_convertible_v<
        typename std::iterator_traits<InputIterator>::iterator_category,
        std::forward_iterator_tag
    >;

    resize(0);
    // In case of not being shared, there is the possibility of having free space at begin
    // even after the resize to zero.
    if (const auto offset = d.freeSpaceAtBegin())
        d.setBegin(d.begin() - offset);

    if constexpr (IsFwdIt)
        reserve(static_cast<qsizetype>(std::distance(first, last)));

    auto toUtf16 = QStringDecoder(QStringDecoder::Utf8);
    auto availableCapacity = d.constAllocatedCapacity();
    auto *dst = d.data();
    auto *dend = d.data() + availableCapacity;

    while (true) {
        if (first == last) {                                    // ran out of input elements
            Q_ASSERT(!std::less<>{}(dend, dst));
            d.size = dst - d.begin();
            return;
        }
        const ValueType next = *first; // decays proxies, if any
        const auto chunk = QUtf8StringView(&next, 1);
        // UTF-8 characters can have a maximum size of 4 bytes and may result in a surrogate
        // pair of UTF-16 code units. In the input-iterator case, we don't know the size
        // and would need to always reserve space for 2 code units. To keep our promise
        // of 'not allocating if it fits', we have to pre-check this condition.
        //          We know that it fits in the forward-iterator case.
        if constexpr (!IsFwdIt) {
            constexpr qsizetype Pair = 2;
            char16_t buf[Pair];
            const qptrdiff n = toUtf16.appendToBuffer(buf, chunk) - buf;
            if (dend - dst < n) {                               // ran out of allocated memory
                const auto offset = dst - d.begin();
                reallocData(d.constAllocatedCapacity() + Pair, QArrayData::Grow);
                // update the pointers since we've re-allocated
                availableCapacity = d.constAllocatedCapacity();
                dst = d.data() + offset;
                dend = d.data() + availableCapacity;
            }
            dst = std::copy_n(buf, n, dst);
        } else {                                                // take the fast path
            dst = toUtf16.appendToBuffer(dst, chunk);
        }
        ++first;
    }
}

QT_END_NAMESPACE

#endif