/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qqmlprofilerevent_p.h"
#include <QtCore/qdatastream.h>

QT_BEGIN_NAMESPACE

bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
{
    if (event1.timestamp() != event2.timestamp() || event1.typeIndex() != event2.typeIndex())
        return false;

    // This is not particularly efficient, but we also don't need to do this very often.
    return event1.numbers<QVarLengthArray<qint64>>() == event2.numbers<QVarLengthArray<qint64>>();
}

bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
{
    return !(event1 == event2);
}

enum SerializationType {
    OneByte    = 0,
    TwoByte    = 1,
    FourByte   = 2,
    EightByte  = 3,
    TypeMask   = 0x3
};

enum SerializationTypeOffset {
    TimestampOffset  = 0,
    TypeIndexOffset  = 2,
    DataLengthOffset = 4,
    DataOffset       = 6
};

template<typename Number>
static inline void readNumbers(QDataStream &stream, Number *data, quint16 length)
{
    for (quint16 i = 0; i != length; ++i)
        stream >> data[i];
}

template<typename Number>
static inline Number readNumber(QDataStream &stream, qint8 type)
{
    switch (type) {
    case OneByte: {
        qint8 value;
        stream >> value;
        return static_cast<Number>(value);
    }
    case TwoByte: {
        qint16 value;
        stream >> value;
        return static_cast<Number>(value);
    }
    case FourByte: {
        qint32 value;
        stream >> value;
        return static_cast<Number>(value);
    }
    case EightByte: {
        qint64 value;
        stream >> value;
        return static_cast<Number>(value);
    }
    default:
        Q_UNREACHABLE();
        return 0;
    }
}

QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event)
{
    qint8 type;
    stream >> type;

    event.m_timestamp = readNumber<qint64>(stream, (type >> TimestampOffset) & TypeMask);
    event.m_typeIndex = readNumber<qint32>(stream, (type >> TypeIndexOffset) & TypeMask);
    event.m_dataLength = readNumber<quint16>(stream, (type >> DataLengthOffset) & TypeMask);

    uint bytesPerNumber = 1 << ((type >> DataOffset) & TypeMask);

    if (event.m_dataLength * bytesPerNumber > sizeof(event.m_data)) {
        event.m_dataType = static_cast<QQmlProfilerEvent::Type>((bytesPerNumber * 8)
                                                                | QQmlProfilerEvent::External);
        event.m_data.external = malloc(event.m_dataLength * bytesPerNumber);
    } else {
        event.m_dataType = static_cast<QQmlProfilerEvent::Type>(bytesPerNumber * 8);
    }

    switch (event.m_dataType) {
    case QQmlProfilerEvent::Inline8Bit:
        readNumbers<qint8>(stream, event.m_data.internal8bit, event.m_dataLength);
        break;
    case QQmlProfilerEvent::External8Bit:
        readNumbers<qint8>(stream, static_cast<qint8 *>(event.m_data.external),
                           event.m_dataLength);
        break;
    case QQmlProfilerEvent::Inline16Bit:
        readNumbers<qint16>(stream, event.m_data.internal16bit, event.m_dataLength);
        break;
    case QQmlProfilerEvent::External16Bit:
        readNumbers<qint16>(stream, static_cast<qint16 *>(event.m_data.external),
                            event.m_dataLength);
        break;
    case QQmlProfilerEvent::Inline32Bit:
        readNumbers<qint32>(stream, event.m_data.internal32bit, event.m_dataLength);
        break;
    case QQmlProfilerEvent::External32Bit:
        readNumbers<qint32>(stream, static_cast<qint32 *>(event.m_data.external),
                            event.m_dataLength);
        break;
    case QQmlProfilerEvent::Inline64Bit:
        readNumbers<qint64>(stream, event.m_data.internal64bit, event.m_dataLength);
        break;
    case QQmlProfilerEvent::External64Bit:
        readNumbers<qint64>(stream, static_cast<qint64 *>(event.m_data.external),
                            event.m_dataLength);
        break;
    default:
        Q_UNREACHABLE();
        break;
    }

    return stream;
}

static inline qint8 minimumType(const QQmlProfilerEvent &event, quint16 length,
                                quint16 origBitsPerNumber)
{
    qint8 type = OneByte;
    bool ok = true;
    for (quint16 i = 0; i < length;) {
        if ((1 << type) == origBitsPerNumber / 8)
            return type;
        switch (type) {
        case OneByte:
            ok = (event.number<qint8>(i) == event.number<qint64>(i));
            break;
        case TwoByte:
            ok = (event.number<qint16>(i) == event.number<qint64>(i));
            break;
        case FourByte:
            ok = (event.number<qint32>(i) == event.number<qint64>(i));
            break;
        default:
            // EightByte isn't possible, as (1 << type) == origBitsPerNumber / 8 then.
            Q_UNREACHABLE();
            break;
        }

        if (ok)
            ++i;
        else
            ++type;
    }
    return type;
}

template<typename Number>
static inline qint8 minimumType(Number number)
{
     if (static_cast<qint8>(number) == number)
         return OneByte;
     if (static_cast<qint16>(number) == number)
         return TwoByte;
     if (static_cast<qint32>(number) == number)
         return FourByte;
     return EightByte;
}

template<typename Number>
static inline void writeNumbers(QDataStream &stream, const QQmlProfilerEvent &event, quint16 length)
{
    for (quint16 i = 0; i != length; ++i)
        stream << event.number<Number>(i);
}

template<typename Number>
static inline void writeNumber(QDataStream &stream, Number number, qint8 type)
{
    switch (type) {
    case OneByte:
        stream << static_cast<qint8>(number);
        break;
    case TwoByte:
        stream << static_cast<qint16>(number);
        break;
    case FourByte:
        stream << static_cast<qint32>(number);
        break;
    case EightByte:
        stream << static_cast<qint64>(number);
        break;
    default:
        Q_UNREACHABLE();
        break;
    }
}

QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event)
{
    qint8 type = minimumType(event.m_timestamp); // << TimestampOffset;
    type |= minimumType(event.m_typeIndex) << TypeIndexOffset;
    type |= minimumType(event.m_dataLength) << DataLengthOffset;
    type |= minimumType(event, event.m_dataLength, event.m_dataType) << DataOffset;
    stream << type;

    writeNumber(stream, event.m_timestamp, (type >> TimestampOffset) & TypeMask);
    writeNumber(stream, event.m_typeIndex, (type >> TypeIndexOffset) & TypeMask);
    writeNumber(stream, event.m_dataLength, (type >> DataLengthOffset) & TypeMask);

    switch ((type >> DataOffset) & TypeMask) {
    case OneByte:
        writeNumbers<qint8>(stream, event, event.m_dataLength);
        break;
    case TwoByte:
        writeNumbers<qint16>(stream, event, event.m_dataLength);
        break;
    case FourByte:
        writeNumbers<qint32>(stream, event, event.m_dataLength);
        break;
    case EightByte:
        writeNumbers<qint64>(stream, event, event.m_dataLength);
        break;
    default:
        Q_UNREACHABLE();
        break;
    }

    return stream;
}

QT_END_NAMESPACE