#include "binarystreamreader.h"

#include "floatswap.h"

BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    skipByteRequested = false;

    skipSampleRequested = false;

    sampleCount = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::numOfChannelsChanged);

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::onNumOfChannelsChanged);

    // initial number format selection

    onNumberFormatChanged(_settingsWidget.numberFormat());

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,

            this, &BinaryStreamReader::onNumberFormatChanged);

    // enable skip byte and sample buttons

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,

            [this]()

            {

                skipByteRequested = true;

            });

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,

            [this]()

            {

                skipSampleRequested = true;

            });

}

QWidget* BinaryStreamReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned BinaryStreamReader::numOfChannels()

{

    return _numOfChannels;

}

void BinaryStreamReader::enable(bool enabled)

{

    if (enabled)

    {

        QObject::connect(_device, &QIODevice::readyRead,

                         this, &BinaryStreamReader::onDataReady);

    }

    else

    {

        QObject::disconnect(_device, 0, this, 0);

    }

}

void BinaryStreamReader::pause(bool enabled)

{

    paused = enabled;

}

void BinaryStreamReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

            sampleSize = 1;

            readSample = &BinaryStreamReader::readSampleAs<quint8>;

            break;

        case NumberFormat_int8:

            sampleSize = 1;

            readSample = &BinaryStreamReader::readSampleAs<qint8>;

            break;

        case NumberFormat_uint16:

            sampleSize = 2;

            readSample = &BinaryStreamReader::readSampleAs<quint16>;

            break;

        case NumberFormat_int16:

            sampleSize = 2;

            readSample = &BinaryStreamReader::readSampleAs<qint16>;

            break;

        case NumberFormat_uint32:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<quint32>;

            break;

        case NumberFormat_int32:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<qint32>;

            break;

        case NumberFormat_float:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<float>;

            break;

    }

}

void BinaryStreamReader::onNumOfChannelsChanged(unsigned value)

{

    _numOfChannels = value;

}

void BinaryStreamReader::onDataReady()

{

    // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

    int packageSize = sampleSize * _numOfChannels;

    int bytesAvailable = _device->bytesAvailable();

    // skip 1 byte if requested

    if (bytesAvailable > 0 && skipByteRequested)

    {

        _device->read(1);

        skipByteRequested = false;

        bytesAvailable--;

    }

    // skip 1 sample (channel) if requested

    if (bytesAvailable >= (int) sampleSize && skipSampleRequested)

    {

        _device->read(sampleSize);

        skipSampleRequested = false;

        bytesAvailable--;

    }

    if (bytesAvailable < packageSize) return;

    int numOfPackagesToRead =

        (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;

    if (paused)

    {

        // read and discard data

        _device->read(numOfPackagesToRead*packageSize);

        return;

    }

    double* channelSamples = new double[numOfPackagesToRead*_numOfChannels];

    for (int i = 0; i < numOfPackagesToRead; i++)

    {

        for (unsigned int ci = 0; ci < _numOfChannels; ci++)

        {

            // channelSamples[ci].replace(i, (this->*readSample)());

            channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();

        }

    }

    for (unsigned int ci = 0; ci < _numOfChannels; ci++)

    {

        addChannelData(ci,

                       channelSamples + ci*numOfPackagesToRead,

                       numOfPackagesToRead);

    }

    emit dataAdded();

    delete channelSamples;

}

template<typename T> double BinaryStreamReader::readSampleAs()

{

    T data;

    _device->read((char*) &data, sizeof(data));

    if (_settingsWidget.endianness() == LittleEndian)

    {

        data = qFromLittleEndian(data);

    }

    else

    {

        data = qFromBigEndian(data);

    }

    return double(data);

}

void BinaryStreamReader::addChannelData(unsigned int channel,

                                        double* data, unsigned size)

{

    _channelMan->addChannelData(channel, data, size);

    sampleCount += size;

}

void BinaryStreamReader::saveSettings(QSettings* settings)

{

    _settingsWidget.saveSettings(settings);

}

void BinaryStreamReader::loadSettings(QSettings* settings)

{

    paused = false;

    // initial settings

    settingsInvalid = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    hasSizeByte = _settingsWidget.frameSize() == 0;

    frameSize = _settingsWidget.frameSize();

    syncWord = _settingsWidget.syncWord();

    checksumEnabled = _settingsWidget.isChecksumEnabled();

    onNumberFormatChanged(_settingsWidget.numberFormat());

    debugModeEnabled = _settingsWidget.isDebugModeEnabled();

    checkSettings();

    // init setting connections

    connect(&_settingsWidget, &FramedReaderSettings::numberFormatChanged,

            this, &FramedReader::onNumberFormatChanged);

    connect(&_settingsWidget, &FramedReaderSettings::numOfChannelsChanged,

            this, &FramedReader::onNumOfChannelsChanged);

    connect(&_settingsWidget, &FramedReaderSettings::syncWordChanged,

            this, &FramedReader::onSyncWordChanged);

    connect(&_settingsWidget, &FramedReaderSettings::frameSizeChanged,

            this, &FramedReader::onFrameSizeChanged);

    connect(&_settingsWidget, &FramedReaderSettings::checksumChanged,

            [this](bool enabled){checksumEnabled = enabled; reset();});

    connect(&_settingsWidget, &FramedReaderSettings::debugModeChanged,

            [this](bool enabled){debugModeEnabled = enabled;});

    // init reader state

    reset();

}

void FramedReader::enable(bool enabled)

{

    if (enabled)

    {

        connect(_device, &QIODevice::readyRead,

                this, &FramedReader::onDataReady);

    }

    else

    {

        QObject::disconnect(_device, 0, this, 0);

    }

}

QWidget* FramedReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned FramedReader::numOfChannels()

{

    return _numOfChannels;

}

void FramedReader::pause(bool enabled)

{

    paused = enabled;

}

void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

            sampleSize = 1;

            readSample = &FramedReader::readSampleAs<quint8>;

            break;

        case NumberFormat_int8:

            sampleSize = 1;

            readSample = &FramedReader::readSampleAs<qint8>;

            break;

        case NumberFormat_uint16:

            sampleSize = 2;

            readSample = &FramedReader::readSampleAs<quint16>;

            break;

        case NumberFormat_int16:

            sampleSize = 2;

            readSample = &FramedReader::readSampleAs<qint16>;

            break;

        case NumberFormat_uint32:

            sampleSize = 4;

            readSample = &FramedReader::readSampleAs<quint32>;

            break;

        case NumberFormat_int32:

            sampleSize = 4;

            readSample = &FramedReader::readSampleAs<qint32>;

            break;

        case NumberFormat_float:

            sampleSize = 4;

            readSample = &FramedReader::readSampleAs<float>;

            break;

    }

    checkSettings();

    reset();

}

void FramedReader::checkSettings()

{

    // sync word is invalid (empty or missing a nibble at the end)

    if (!syncWord.size())

    {

        settingsInvalid |= SYNCWORD_INVALID;

    }

    else // sync word is valid

    {

        settingsInvalid &= ~SYNCWORD_INVALID;

    }

    // check if fixed frame size is multiple of a sample set size

    if (!hasSizeByte && frameSize % (_numOfChannels * sampleSize) != 0)

    {

        settingsInvalid |= FRAMESIZE_INVALID;

    }

    else

    {

        settingsInvalid &= ~FRAMESIZE_INVALID;

    }

    // show an error message

    if (settingsInvalid & SYNCWORD_INVALID)

    {

        _settingsWidget.showMessage("Sync word is invalid!", true);

    }

    else if (settingsInvalid & FRAMESIZE_INVALID)

    {

        QString errorMessage =

            QString("Frame size must be multiple of %1 (#channels * sample size)!")\

            .arg(_numOfChannels * sampleSize);

        _settingsWidget.showMessage(errorMessage, true);

    }

    else

    {

        _settingsWidget.showMessage("All is well!");

    }

}

void FramedReader::onNumOfChannelsChanged(unsigned value)

{

    _numOfChannels = value;

    checkSettings();

    reset();

    emit numOfChannelsChanged(value);

}

void FramedReader::onSyncWordChanged(QByteArray word)

{

    syncWord = word;

    checkSettings();

    reset();

}

void FramedReader::onFrameSizeChanged(unsigned value)

{

    if (value == 0)

    {

        hasSizeByte = true;

    }

    else

    {

        hasSizeByte = false;

        frameSize = value;

    }

    checkSettings();

    reset();

}

void FramedReader::onDataReady()

{

    if (settingsInvalid) return;

    // loop until we run out of bytes or more bytes is required

    unsigned bytesAvailable;

    while ((bytesAvailable = _device->bytesAvailable()))

    {

        if (!gotSync) // read sync word

        {

            char c;

            _device->getChar(&c);

            if (c == syncWord[sync_i]) // correct sync byte?

            {

                sync_i++;

                if (sync_i == (unsigned) syncWord.length())

                {

                    gotSync = true;

                }