/*

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

#include "utils.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;

}

/*

  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 DATAFORMATPANEL_H

#define DATAFORMATPANEL_H

#include <QWidget>

#include <QButtonGroup>

#include <QTimer>

#include <QSerialPort>

#include <QList>

#include <QtGlobal>

#include "framebuffer.h"

#include "channelmanager.h"

#include "binarystreamreader.h"

#include "asciireader.h"

#include "demoreader.h"

#include "framedreader.h"

namespace Ui {

class DataFormatPanel;

}

class DataFormatPanel : public QWidget

{

    Q_OBJECT

public:

    explicit DataFormatPanel(QSerialPort* port,

                             ChannelManager* channelMan,

                             QWidget *parent = 0);

    ~DataFormatPanel();

    unsigned numOfChannels();

public slots:

    void pause(bool);

    void enableDemo(bool); // demo shouldn't be enabled when port is open

signals:

    void numOfChannelsChanged(unsigned);

    void samplesPerSecondChanged(unsigned);

    void dataAdded();

private:

    Ui::DataFormatPanel *ui;

    QSerialPort* serialPort;

    ChannelManager* _channelMan;

    BinaryStreamReader bsReader;

    AsciiReader asciiReader;

    FramedReader framedReader;

    /// Currently selected reader

    AbstractReader* currentReader;

    /// Disable current reader and enable a another one

    void selectReader(AbstractReader* reader);

    bool paused;

    DemoReader demoReader;

    // `data` contains i th channels data

    void addChannelData(unsigned int channel, double* data, unsigned size);

};

#endif // DATAFORMATPANEL_H

}

void MainWindow::onPortError(QSerialPort::SerialPortError error)

{

    switch(error)

    {

        case QSerialPort::NoError :

            break;

        case QSerialPort::ResourceError :

            qWarning() << "Port error: resource unavaliable; most likely device removed.";

            if (serialPort.isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort.portName();

                portControl.togglePort();

            }

            portControl.loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort.portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

            qCritical() << "Device is not open!";

            break;

        case QSerialPort::ParityError:

            qCritical() << "Parity error detected.";

            break;

        case QSerialPort::FramingError:

            qCritical() << "Framing error detected.";

            break;

        case QSerialPort::BreakConditionError:

            qCritical() << "Break condition is detected.";

            break;

        case QSerialPort::WriteError:

            qCritical() << "An error occurred while writing data.";

            break;

        case QSerialPort::ReadError:

            qCritical() << "An error occurred while reading data.";

            break;

        case QSerialPort::UnsupportedOperationError:

            qCritical() << "Operation is not supported.";

            break;

        case QSerialPort::TimeoutError:

            qCritical() << "A timeout error occurred.";

            break;

        case QSerialPort::UnknownError:

            qCritical() << "Unknown error! Error: " << serialPort.errorString();

            break;

        default:

            qCritical() << "Unhandled port error: " << error;

            break;

    }

}

void MainWindow::clearPlot()

{

    for (unsigned ci = 0; ci < channelMan.numOfChannels(); ci++)

    {

        channelMan.channelBuffer(ci)->clear();

    }

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    channelMan.setNumOfSamples(value);

    plotMan->replot();

}

void MainWindow::onNumOfChannelsChanged(unsigned value)

{

    unsigned int oldNum = plotMan->numOfCurves();

    unsigned numOfChannels = value;

    if (numOfChannels > oldNum)

    {

        // add new channels

        for (unsigned int i = oldNum; i < numOfChannels; i++)

        {

            plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));

        }

    }

    else if(numOfChannels < oldNum)

    {

        plotMan->removeCurves(oldNum - numOfChannels);

    }

    plotMan->replot();

}

void MainWindow::onChannelNameChanged(unsigned channel, QString name)

{

    // This slot is triggered also when a new channel is added, in

    // this case curve list doesn't contain said channel. No worries,

    // since `onNumOfChannelsChanged` slot will update curve list.

    if (channel < plotMan->numOfCurves()) // check if channel exists in curve list

    {

        plotMan->setTitle(channel, name);

    }

}

void MainWindow::onSpsChanged(unsigned sps)

{

    spsLabel.setText(QString::number(sps) + "sps");

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            dataFormatPanel.enableDemo(true);

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        dataFormatPanel.enableDemo(false);

        ui->actionDemoMode->setChecked(false);

    }

}

void MainWindow::onExportCsv()

{

    bool wasPaused = ui->actionPause->isChecked();

    ui->actionPause->setChecked(true); // pause plotting

    QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));

    if (fileName.isNull())  // user canceled export

    {

        ui->actionPause->setChecked(wasPaused);

    }

    else

    {

        Snapshot* snapshot = snapshotMan.makeSnapshot();

        snapshot->save(fileName);

        delete snapshot;

    }

}

void MainWindow::messageHandler(QtMsgType type,

                                const QMessageLogContext &context,

                                const QString &msg)

{

    QString logString;

    switch (type)

    {

        case QtDebugMsg:

            logString = "[Debug] " + msg;

            break;

        case QtWarningMsg:

            logString = "[Warning] " + msg;

            break;

        case QtCriticalMsg:

            logString = "[Error] " + msg;

            break;

        case QtFatalMsg:

            logString = "[Fatal] " + msg;

            break;

    }

    if (ui != NULL) ui->ptLog->appendPlainText(logString);

    std::cerr << logString.toStdString() << std::endl;

    if (type != QtDebugMsg && ui != NULL)

    {

        ui->statusBar->showMessage(msg, 5000);

    }

}

void MainWindow::saveAllSettings(QSettings* settings)

{

    saveMWSettings(settings);

    portControl.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

}

void MainWindow::saveMWSettings(QSettings* settings)

{

    // save window geometry

    settings->beginGroup(SettingGroup_MainWindow);

    settings->setValue(SG_MainWindow_Size, size());

    settings->setValue(SG_MainWindow_Pos, pos());

    // save active panel

    settings->setValue(SG_MainWindow_ActivePanel,

                       panelSettingMap.value(ui->tabWidget->currentIndex()));

    settings->endGroup();

}

void MainWindow::loadMWSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_MainWindow);

    // load window geometry

    resize(settings->value(SG_MainWindow_Size, size()).toSize());

    move(settings->value(SG_MainWindow_Pos, pos()).toPoint());

    // set active panel

    QString tabSetting =

        settings->value(SG_MainWindow_ActivePanel, QString()).toString();

    ui->tabWidget->setCurrentIndex(

        panelSettingMap.key(tabSetting, ui->tabWidget->currentIndex()));

    settings->endGroup();

}

void MainWindow::onSaveSettings()

{

    QString fileName = QFileDialog::getSaveFileName(

        this, tr("Save Settings"), QString(), "INI (*.ini)");

    if (!fileName.isNull()) // user canceled

    {

        QSettings settings(fileName, QSettings::IniFormat);

        saveAllSettings(&settings);

    }

}

void MainWindow::onLoadSettings()

{

    QString fileName = QFileDialog::getOpenFileName(

        this, tr("Load Settings"), QString(), "INI (*.ini)");

    if (!fileName.isNull()) // user canceled

    {

        QSettings settings(fileName, QSettings::IniFormat);

        loadAllSettings(&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_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";

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

#endif // SETTING_DEFINES_H