/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <QtEndian>

#include <QtDebug>

#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;

        case NumberFormat_INVALID:

            Q_ASSERT(1); // never

            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();

}

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)

{

    _settingsWidget.loadSettings(settings);

}

/*

  Copyright © 2015 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "framebuffer.h"

FrameBuffer::FrameBuffer(size_t size)

{

    _size = size;

    data = new double[_size]();

    headIndex = 0;

    _boundingRect.setCoords(0, 0, size, 0);

}

FrameBuffer::~FrameBuffer()

{

}

void FrameBuffer::resize(size_t size)

{

    int offset = size - _size;

    if (offset == 0) return;

    double* newData = new double[size];

    // move data to new array

    int fill_start = offset > 0 ? offset : 0;

    for (int i = fill_start; i < int(size); i++)

    {

        newData[i] = sample(i - offset);

    }

    // fill the beginning of the new data

    if (fill_start > 0)

    {

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

        {

            newData[i] = 0;

        }

    }

    // data is ready, clean and re-point

    delete data;

    data = newData;

    headIndex = 0;

    _size = size;

    // update the bounding rectangle

    _boundingRect.setRight(_size);

}

void FrameBuffer::addSamples(double* samples, size_t size)

{

    unsigned shift = size;

    if (shift < _size)

    {

        unsigned x = _size - headIndex; // distance of `head` to end

        if (shift <= x) // there is enough room at the end of array

        {

            for (size_t i = 0; i < shift; i++)

            {

                data[i+headIndex] = samples[i];

            }

            if (shift == x) // we used all the room at the end

            {

                headIndex = 0;

            }

            else

            {

                headIndex += shift;

            }

        }

        else // there isn't enough room

        {

            for (size_t i = 0; i < x; i++) // fill the end part

            {

                data[i+headIndex] = samples[i];

            }

            for (size_t i = 0; i < (shift-x); i++) // continue from the beginning

            {

                data[i] = samples[i+x];

            }

            headIndex = shift-x;

        }

    }

    else // number of new samples equal or bigger than current size

    {

        int x = shift - _size;

        for (size_t i = 0; i < _size; i++)

        {

            data[i] = samples[i+x];

        }

        headIndex = 0;

    }

    // update bounding rectangle

    double minValue = data[0];

    double maxValue = data[0];

    for (size_t i = 0; i < _size; i++)

    {

        if (data[i] > maxValue)

        {

            maxValue = data[i];

        }

        else if (data[i] < minValue)

        {

            minValue = data[i];

        }

    }

    _boundingRect.setTop(minValue);

    _boundingRect.setBottom(maxValue);

}

void FrameBuffer::clear()

{

    for (size_t i=0; i < _size; i++) data[i] = 0.;

}

size_t FrameBuffer::size() const

{

    return _size;

}

QRectF FrameBuffer::boundingRect() const

{

    return _boundingRect;

}

double FrameBuffer::sample(size_t i) const

{

    size_t index = headIndex + i;

    if (index >= _size) index -= _size;

    return data[index];

}

    // 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;

                }

            }

            else

            {

                if (debugModeEnabled) qCritical() << "Missed " << sync_i+1 << "th sync byte.";

            }

        }

        else if (hasSizeByte && !gotSize) // skipped if fixed frame size

        {

            frameSize = 0;

            _device->getChar((char*) &frameSize);

            if (frameSize == 0) // check size

            {

                qCritical() << "Frame size is 0!";

                reset();

            }

            else if (frameSize % (_numOfChannels * sampleSize) != 0)

            {

                qCritical() <<

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

                    .arg(_numOfChannels * sampleSize);

                reset();

            }

            else

            {

                if (debugModeEnabled) qDebug() << "Frame size:" << frameSize;

                gotSize = true;

            }

        }

        else // read data bytes

        {

            // have enough data bytes? (+1 for checksum)

            if (bytesAvailable < (checksumEnabled ? frameSize+1 : frameSize))

            {

                break;

            }

            else // read data bytes and checksum

            {

                readFrameDataAndCheck();

                reset();

            }

        }

    }

}

void FramedReader::reset()

{

    sync_i = 0;

    gotSync = false;

    gotSize = false;

    if (hasSizeByte) frameSize = 0;

    calcChecksum = 0;

}

// Important: this function assumes device has enough bytes to read a full frames data and checksum

void FramedReader::readFrameDataAndCheck()

{

    // if paused just read and waste data

    if (paused)

    {

        _device->read((checksumEnabled ? frameSize+1 : frameSize));

        return;

    }

    // a package is 1 set of samples for all channels

    unsigned numOfPackagesToRead = frameSize / (_numOfChannels * sampleSize);

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

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

    {

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

        {

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

        }

    }

    // read checksum

    unsigned rChecksum = 0;

    bool checksumPassed = false;

    if (checksumEnabled)

    {

        _device->read((char*) &rChecksum, 1);

        calcChecksum &= 0xFF;

        checksumPassed = (calcChecksum == rChecksum);

    }

    if (!checksumEnabled || checksumPassed)

    {

        // commit data

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

        {

            _channelMan->addChannelData(

                ci,

                channelSamples + ci*numOfPackagesToRead,

                numOfPackagesToRead);

            sampleCount += numOfPackagesToRead;

        }

        emit dataAdded();

    }

    else

    {

        qCritical() << "Checksum failed! Received:" << rChecksum << "Calculated:" << calcChecksum;

    }

}

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

{

    T data;

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

    if (checksumEnabled)

    {

        for (unsigned i = 0; i < sizeof(data); i++)

        {

            calcChecksum += ((unsigned char*) &data)[i];

        }

    }

    if (_settingsWidget.endianness() == LittleEndian)

    {

        data = qFromLittleEndian(data);

    }

    else

    {

        data = qFromBigEndian(data);

    }

    return double(data);

}

void FramedReader::saveSettings(QSettings* settings)

{

    _settingsWidget.saveSettings(settings);

}

void FramedReader::loadSettings(QSettings* settings)

{

    _settingsWidget.loadSettings(settings);

}