/*

  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 <QtDebug>

#include <QtEndian>

#include "floatswap.h"

#include "framedreader.h"

{

    paused = false;

    // initial settings

    settingsInvalid = 0;

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

}

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;

}

{

}

void FramedReader::pause(bool enabled)

{

    paused = enabled;

}

void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

{

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

    {

        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)!")\

        _settingsWidget.showMessage(errorMessage, true);

    }

    else

    {

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

    }

}

void FramedReader::onNumOfChannelsChanged(unsigned value)

{

    checkSettings();

    reset();

    emit numOfChannelsChanged(value);

}

void FramedReader::onSyncWordChanged(QByteArray word)

{

    syncWord = word;

    checkSettings();

    reset();

}

            }

        }

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

            }

            {

                qCritical() <<

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

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

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

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

    {

        {

        }

    }

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

    }

    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++)

        {

/*

  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.

#include "abstractreader.h"

#include "framedreadersettings.h"

/**

 * Reads data in a customizable framed format.

 */

class FramedReader : public AbstractReader

{

    Q_OBJECT

public:

    QWidget* settingsWidget();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

private:

    /// bit wise fields for `settingsValid` member

    enum SettingInvalidFlag

    {

        SYNCWORD_INVALID = 1,

        FRAMESIZE_INVALID = 2

    };

    // settings related members

    FramedReaderSettings _settingsWidget;

    unsigned sampleSize;

    bool paused;

    unsigned settingsInvalid;   /// settings are all valid if this is 0, if not no reading is done

    QByteArray syncWord;

    bool checksumEnabled;

    bool hasSizeByte;

    unsigned frameSize;

    bool debugModeEnabled;

    /// Checks the validity of syncWord and frameSize then shows an

    /// error message. Also updates `settingsInvalid`. If settings are

    /// valid `settingsInvalid` should be `0`.

  ../src/ringbuffer.cpp

  ../src/readonlybuffer.cpp

  ../src/stream.cpp

  ../src/streamchannel.cpp

  ../src/channelinfomodel.cpp

  )

add_test(NAME test1 COMMAND Test)

qt5_use_modules(Test Widgets)

qt5_wrap_ui(UI_FILES_T

  ../src/binarystreamreadersettings.ui

  ../src/asciireadersettings.ui

  ../src/numberformatbox.ui

  ../src/endiannessbox.ui

  )

# test for readers

add_executable(TestReaders EXCLUDE_FROM_ALL

  test_readers.cpp

  ../src/samplepack.cpp

  ../src/sink.cpp

  ../src/source.cpp

  ../src/abstractreader.cpp

  ../src/binarystreamreader.cpp

  ../src/binarystreamreadersettings.cpp

  ../src/asciireader.cpp

  ../src/asciireadersettings.cpp

  ../src/endiannessbox.cpp

  ../src/numberformatbox.cpp

  ../src/numberformat.cpp

  ${UI_FILES_T}

  )

qt5_use_modules(TestReaders Widgets Test)

add_test(NAME test_readers COMMAND TestReaders)

set(CMAKE_CTEST_COMMAND ctest -V)

add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})

add_dependencies(check Test TestReaders)

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

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

*/

// This tells Catch to provide a main() - only do this in one cpp file per executable

#define CATCH_CONFIG_RUNNER

#include "catch.hpp"

#include <QSignalSpy>

#include <QBuffer>

#include "binarystreamreader.h"

#include "asciireader.h"

#include "test_helpers.h"

static const int READYREAD_TIMEOUT = 10; // milliseconds

TEST_CASE("reading data with BinaryStreamReader", "[reader]")

{

    QBuffer bufferDev;

    BinaryStreamReader bs(&bufferDev);

    bs.enable(true);

    TestSink sink;

    // inject data to the buffer

    bufferDev.open(QIODevice::ReadWrite);

    bufferDev.write("0,1,3\n0,1,3\n0,1,3\n0,1,3\n");

    bufferDev.seek(0);

    QSignalSpy spy(&bufferDev, SIGNAL(readyRead()));

    REQUIRE_FALSE(spy.wait(READYREAD_TIMEOUT));

    REQUIRE(sink._numChannels == 1);

    REQUIRE(sink._hasX == false);

    REQUIRE(sink.totalFed == 0);

}

// Note: this is added because `QApplication` must be created for widgets

#include <QApplication>

int main(int argc, char* argv[])

{

    QApplication a(argc, argv);

    int result = Catch::Session().run( argc, argv );

    return result;

}