/*

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

#include "asciireader.h"

/// If set to this value number of channels is determined from input

#define NUMOFCHANNELS_AUTO   (0)

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

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    discardFirstLine = true;

    sampleCount = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            [this](unsigned value)

            {

                _numOfChannels = value;

                autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);

                if (!autoNumOfChannels)

                {

                    emit numOfChannelsChanged(value);

                }

            });

    connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});

}

QWidget* AsciiReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned AsciiReader::numOfChannels()

{

    // do not allow '0'

    if (_numOfChannels == 0)

    {

        return 1;

    }

    else

    {

        return _numOfChannels;

    }

}

// TODO: this could be a part of AbstractReader

void AsciiReader::enable(bool enabled)

{

    if (enabled)

    {

        discardFirstLine = true;

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

                         this, &AsciiReader::onDataReady);

    }

    else

    {

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

    }

}

void AsciiReader::pause(bool enabled)

{

    paused = enabled;

}

void AsciiReader::onDataReady()

{

    while(_device->canReadLine())

    {

        QByteArray line = _device->readLine();

        // discard only once when we just started reading

        if (discardFirstLine)

        {

            discardFirstLine = false;

            continue;

        }

        // discard data if paused

        if (paused)

        {

            continue;

        }

        // parse data

        line = line.trimmed();

        // Note: When data coming from pseudo terminal is buffered by

        // system CR is converted to LF for some reason. This causes

        // empty lines in the input when the port is just opened.

        if (line.isEmpty())

        {

            continue;

        }

        auto separatedValues = line.split(',');

        unsigned numReadChannels; // effective number of channels to read

        unsigned numComingChannels = separatedValues.length();

        if (autoNumOfChannels)

        {

            // did number of channels changed?

            if (numComingChannels != _numOfChannels)

            {

                _numOfChannels = numComingChannels;

                emit numOfChannelsChanged(numComingChannels);

            }

            numReadChannels = numComingChannels;

        }

        else if (numComingChannels >= _numOfChannels)

        {

            numReadChannels = _numOfChannels;

        }

        else // there is missing channel data

        {

            numReadChannels = separatedValues.length();

            qWarning() << "Incoming data is missing data for some channels!";

        }

        // parse read line

        for (unsigned ci = 0; ci < numReadChannels; ci++)

        {

            bool ok;

            double channelSample = separatedValues[ci].toDouble(&ok);

            if (ok)

            {

                _channelMan->addChannelData(ci, &channelSample, 1);

                sampleCount++;

            }

            else

            {

                qWarning() << "Data parsing error for channel: " << ci;

            }

        }

        emit dataAdded();

    }

}

/*

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

*/

#ifndef ASCIIREADER_H

#define ASCIIREADER_H

#include "abstractreader.h"

#include "asciireadersettings.h"

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

public slots:

    void pause(bool);

private:

    AsciiReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    /// number of channels will be determined from incoming data

    unsigned autoNumOfChannels;

    bool paused;

    // We may have (usually true) started reading in the middle of a

    // line, so its a better idea to just discard first line.

    bool discardFirstLine;

private slots:

    void onDataReady();

};

#endif // ASCIIREADER_H

/*

  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 "utils.h"

#include "asciireadersettings.h"

#include "ui_asciireadersettings.h"

AsciiReaderSettings::AsciiReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::AsciiReaderSettings)

{

    ui->setupUi(this);

    // Note: if directly connected we get a runtime warning on incompatible signal arguments

    connect(ui->spNumOfChannels, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

}

AsciiReaderSettings::~AsciiReaderSettings()

{

    delete ui;

}

unsigned AsciiReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

/*

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

*/

#ifndef ASCIIREADERSETTINGS_H

#define ASCIIREADERSETTINGS_H

#include <QWidget>

namespace Ui {

class AsciiReaderSettings;

}

class AsciiReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit AsciiReaderSettings(QWidget *parent = 0);

    ~AsciiReaderSettings();

    unsigned numOfChannels();

signals:

    void numOfChannelsChanged(unsigned);

private:

    Ui::AsciiReaderSettings *ui;

};

#endif // ASCIIREADERSETTINGS_H

/*

  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 "dataformatpanel.h"

#include "ui_dataformatpanel.h"

#include <QRadioButton>

#include <QtEndian>

#include <QMap>

#include <QtDebug>

#include "utils.h"

#include "setting_defines.h"

#include "floatswap.h"

DataFormatPanel::DataFormatPanel(QSerialPort* port,

                                 ChannelManager* channelMan,

                                 QWidget *parent) :

    QWidget(parent),

    ui(new Ui::DataFormatPanel),

    bsReader(port, channelMan, this),

    asciiReader(port, channelMan, this),

    framedReader(port, channelMan, this),

    demoReader(port, channelMan, this)

{

    ui->setupUi(this);

    serialPort = port;

    _channelMan = channelMan;

    paused = false;

    // initalize default reader

    currentReader = &bsReader;

    bsReader.enable();

    ui->rbBinary->setChecked(true);

    ui->horizontalLayout->addWidget(bsReader.settingsWidget(), 1);

    connect(&bsReader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

    connect(&bsReader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(&bsReader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // initalize reader selection buttons

    connect(ui->rbBinary, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&bsReader);

            });

    connect(ui->rbAscii, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&asciiReader);

            });

    connect(ui->rbFramed, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&framedReader);

            });

    // re-purpose numofchannels settings from actual reader settings to demo reader

    connect(this, &DataFormatPanel::numOfChannelsChanged,

            &demoReader, &DemoReader::setNumOfChannels);

}

DataFormatPanel::~DataFormatPanel()

{

    delete ui;

}

unsigned DataFormatPanel::numOfChannels()

{

    return currentReader->numOfChannels();

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

    currentReader->pause(enabled);

    demoReader.pause(enabled);

}

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::dataAdded,

                this, &DataFormatPanel::dataAdded);

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

        disconnect(&demoReader, 0, this, 0);

    }

}

void DataFormatPanel::addChannelData(unsigned int channel,

                                     double* data, unsigned size)

{

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

}

void DataFormatPanel::selectReader(AbstractReader* reader)

{

    currentReader->enable(false);

    reader->enable();

    // re-connect signals

    disconnect(currentReader, 0, this, 0);

    connect(reader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

    connect(reader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(reader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // switch the settings widget

    ui->horizontalLayout->removeWidget(currentReader->settingsWidget());

    currentReader->settingsWidget()->hide();

    ui->horizontalLayout->addWidget(reader->settingsWidget(), 1);

    reader->settingsWidget()->show();

    // notify if number of channels is different

    if (currentReader->numOfChannels() != reader->numOfChannels())

    {

        emit numOfChannelsChanged(reader->numOfChannels());

    }

    // pause

    reader->pause(paused);

    currentReader = reader;

}

void DataFormatPanel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_DataFormat);

    // save selected format

    QString format;

    if (currentReader == &bsReader)

    {

        format = "binary";

    }

    else if (currentReader == &asciiReader)

    {

        format = "ascii";

    }

    else // framed reader

    {

        format = "custom";

    }

    settings->setValue(SG_DataFormat_Format, format);

    settings->endGroup();

    // save reader settings

    bsReader.saveSettings(settings);

}

void DataFormatPanel::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_DataFormat);

    // load selected format

    QString format = settings->value(

        SG_DataFormat_Format, QString()).toString();

    if (format == "binary")

    {

        selectReader(&bsReader);

        ui->rbBinary->setChecked(true);

    }

    else if (format == "ascii")

    {

        selectReader(&asciiReader);

        ui->rbAscii->setChecked(true);

    }

    else if (format == "custom")

    {

        selectReader(&framedReader);

        ui->rbFramed->setChecked(true);

    } // else current selection stays

    settings->endGroup();

    // load reader settings

    bsReader.loadSettings(settings);

}

/*

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

*/

#ifndef SETTING_DEFINES_H

#define SETTING_DEFINES_H

const char SettingGroup_MainWindow[] = "MainWindow";

const char SettingGroup_Port[] = "Port";

const char SettingGroup_DataFormat[] = "DataFormat";

const char SettingGroup_Binary[] = "DataFormat_Binary";

const char SettingGroup_Channels[] = "Channels";

const char SettingGroup_Plot[] = "Plot";

const char SettingGroup_Commands[] = "Commands";

// mainwindow setting keys

const char SG_MainWindow_Size[] = "size";

const char SG_MainWindow_Pos[] = "pos";

const char SG_MainWindow_ActivePanel[] = "activePanel";

const char SG_MainWindow_HidePanels[] = "hidePanels";

// port setting keys

const char SG_Port_SelectedPort[] = "selectedPort";

const char SG_Port_BaudRate[] = "baudRate";

const char SG_Port_Parity[] = "parity";

const char SG_Port_DataBits[] = "dataBits";

const char SG_Port_StopBits[] = "stopBits";

const char SG_Port_FlowControl[] = "flowControl";

// data format panel keys

const char SG_DataFormat_Format[] = "format";

// binary stream reader keys

const char SG_Binary_NumOfChannels[] = "numOfChannels";

const char SG_Binary_NumberFormat[] = "numberFormat";

const char SG_Binary_Endianness[] = "endianness";

#endif // SETTING_DEFINES_H