/*

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

#include "ui_mainwindow.h"

#include <QByteArray>

#include <QApplication>

#include <QFileDialog>

#include <QFile>

#include <QTextStream>

#include <QtDebug>

#include <QtEndian>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include <snapshotview.h>

#include "utils.h"

#include "version.h"

#include "floatswap.h"

#if defined(Q_OS_WIN) && defined(QT_STATIC)

#include <QtPlugin>

Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

#endif

struct Range

{

    double rmin;

    double rmax;

};

Q_DECLARE_METATYPE(Range);

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    portControl(&serialPort)

{

    ui->setupUi(this);

    ui->tabWidget->insertTab(0, &portControl, "Port");

    ui->tabWidget->setCurrentIndex(0);

    addToolBar(portControl.toolBar());

    setupAboutDialog();

    // init UI signals

    // menu signals

    QObject::connect(ui->actionHelpAbout, &QAction::triggered,

              &aboutDialog, &QWidget::show);

    QObject::connect(ui->actionExportCsv, &QAction::triggered,

                     this, &MainWindow::onExportCsv);

    QObject::connect(ui->actionQuit, &QAction::triggered,

                     this, &MainWindow::close);

    QObject::connect(ui->actionGrid, &QAction::toggled, [this](bool show)

                     {

                         ui->plot->showGrid(show);

                         ui->actionMinorGrid->setEnabled(show);

                     });

                     this, SLOT(onYScaleChanged()));

    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

                     this, SLOT(clearPlot()));

    QObject::connect(ui->actionSnapShot, SIGNAL(triggered(bool)),

                     this, SLOT(takeSnapShot()));

    // setup number of channels spinbox

    QObject::connect(ui->spNumOfChannels,

                     SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

                     this, &MainWindow::onNumOfChannelsChanged);

    // setup number format buttons

    numberFormatButtons.addButton(ui->rbUint8,  NumberFormat_uint8);

    numberFormatButtons.addButton(ui->rbUint16, NumberFormat_uint16);

    numberFormatButtons.addButton(ui->rbUint32, NumberFormat_uint32);

    numberFormatButtons.addButton(ui->rbInt8,   NumberFormat_int8);

    numberFormatButtons.addButton(ui->rbInt16,  NumberFormat_int16);

    numberFormatButtons.addButton(ui->rbInt32,  NumberFormat_int32);

    numberFormatButtons.addButton(ui->rbFloat,  NumberFormat_float);

    numberFormatButtons.addButton(ui->rbASCII,  NumberFormat_ASCII);

    QObject::connect(&numberFormatButtons, SIGNAL(buttonToggled(int, bool)),

                     this, SLOT(onNumberFormatButtonToggled(int, bool)));

    // init port signals

    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

    // set limits for axis limit boxes

    ui->spYmin->setRange((-1) * std::numeric_limits<double>::max(),

                         std::numeric_limits<double>::max());

    ui->spYmax->setRange((-1) * std::numeric_limits<double>::max(),

                         std::numeric_limits<double>::max());

    // init data arrays and plot

    numOfSamples = ui->spNumOfSamples->value();

    numOfChannels = ui->spNumOfChannels->value();

    // init channel data and curve list

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

    {

        channelBuffers.append(new FrameBuffer(numOfSamples));

        curves.append(new QwtPlotCurve());

        curves[i]->setSamples(channelBuffers[i]);

        curves[i]->attach(ui->plot);

    }

    // init auto scale

    ui->plot->setAxis(ui->cbAutoScale->isChecked(),

                      ui->spYmin->value(), ui->spYmax->value());

    // init grid

    ui->plot->showGrid(ui->actionGrid->isChecked());

    ui->plot->showMinorGrid(ui->actionMinorGrid->isChecked());

    // init scale range preset list

    for (int nbits = 8; nbits <= 24; nbits++) // signed binary formats

    {

        int rmax = pow(2, nbits-1)-1;

        int rmin = -rmax-1;

        Range r = {double(rmin),  double(rmax)};

        ui->cbRangePresets->addItem(

            QString().sprintf("Signed %d bits %d to +%d", nbits, rmin, rmax),

            QVariant::fromValue(r));

    }

    for (int nbits = 8; nbits <= 24; nbits++) // unsigned binary formats

    {

        int rmax = pow(2, nbits)-1;

        ui->cbRangePresets->addItem(

            QString().sprintf("Unsigned %d bits %d to +%d", nbits, 0, rmax),

            QVariant::fromValue(Range{0, double(rmax)}));

    }

    ui->cbRangePresets->addItem("-1 to +1", QVariant::fromValue(Range{-1, +1}));

    ui->cbRangePresets->addItem("0 to +1", QVariant::fromValue(Range{0, +1}));

    ui->cbRangePresets->addItem("-100 to +100", QVariant::fromValue(Range{-100, +100}));

    ui->cbRangePresets->addItem("0 to +100", QVariant::fromValue(Range{0, +100}));

    QObject::connect(ui->cbRangePresets, SIGNAL(activated(int)),

                     this, SLOT(onRangeSelected()));

    // init number format

    if (numberFormatButtons.checkedId() >= 0)

    {

        selectNumberFormat((NumberFormat) numberFormatButtons.checkedId());

    }

    else

    {

        selectNumberFormat(NumberFormat_uint8);

    }

    // Init sps (sample per second) counter

    sampleCount = 0;

    }

}

void MainWindow::skipByte()

{

    skipByteRequested = true;

}

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

{

    channelBuffers[channel]->addSamples(data, size);

    sampleCount += size;

}

void MainWindow::clearPlot()

{

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

    {

        channelBuffers[ci]->clear();

    }

    ui->plot->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

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

    {

        channelBuffers[ci]->resize(numOfSamples);

    }

    ui->plot->replot();

}

void MainWindow::onNumOfChannelsChanged(int value)

{

    unsigned int oldNum = this->numOfChannels;

    this->numOfChannels = value;

    if (numOfChannels > oldNum)

    {

        // add new channels

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

        {

            channelBuffers.append(new FrameBuffer(numOfSamples));

            curves.append(new QwtPlotCurve());

            curves.last()->setSamples(channelBuffers.last());

            curves.last()->attach(ui->plot);

        }

    }

    else if(numOfChannels < oldNum)

    {

        // remove channels

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

        {

            // also deletes owned FrameBuffer

            delete curves.takeLast();

            channelBuffers.removeLast();

        }

    }

}

void MainWindow::onAutoScaleChecked(bool checked)

{

    if (checked)

    {

        ui->plot->setAxis(true);

        ui->lYmin->setEnabled(false);

        ui->lYmax->setEnabled(false);

        ui->spYmin->setEnabled(false);

        ui->spYmax->setEnabled(false);

    }

    else

    {

        ui->lYmin->setEnabled(true);

        ui->lYmax->setEnabled(true);

        ui->spYmin->setEnabled(true);

        ui->spYmax->setEnabled(true);

        ui->plot->setAxis(false,  ui->spYmin->value(), ui->spYmax->value());

    }

}

void MainWindow::onYScaleChanged()

{

    ui->plot->setAxis(false,  ui->spYmin->value(), ui->spYmax->value());

}

void MainWindow::onRangeSelected()

{

    Range r = ui->cbRangePresets->currentData().value<Range>();

    ui->spYmin->setValue(r.rmin);

    ui->spYmax->setValue(r.rmax);

    ui->cbAutoScale->setChecked(false);

}

{

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

    sampleCount = 0;

}

void MainWindow::demoTimerTimeout()

{

    const double period = 100;

    demoCount++;

    if (demoCount > 100) demoCount = 0;

    if (!ui->actionPause->isChecked())

    {

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

        {

            // we are calculating the fourier components of square wave

            double value = 4*sin(2*M_PI*double((ci+1)*demoCount)/period)/((2*(ci+1))*M_PI);

            addChannelData(ci, &value, 1);

        }

        ui->plot->replot();

    }

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            demoTimer.start();

            ui->actionDemoMode->setChecked(true);

            demoIndicator.show();

            ui->plot->replot();

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        demoTimer.stop();

        ui->actionDemoMode->setChecked(false);

        demoIndicator.hide();

        ui->plot->replot();

    }

}

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

    {

        QFile file(fileName);

        if (file.open(QIODevice::WriteOnly | QIODevice::Text))

        {

            QTextStream fileStream(&file);

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

            {

                fileStream << "Channel " << ci;

                if (ci != numOfChannels-1) fileStream << ",";

            }

            fileStream << '\n';

            for (unsigned int i = 0; i < numOfSamples; i++)

            {

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

                {

                    fileStream << channelBuffers[ci]->sample(i).y();

                    if (ci != numOfChannels-1) fileStream << ",";

                }

                fileStream << '\n';

            }

        }

        else

        {

            qCritical() << "File open error during export: " << file.error();

        }

    }

}

void MainWindow::messageHandler(QtMsgType type,

                                const QMessageLogContext &context,

                                const QString &msg)

{

    QString logString;

        NumberFormat_int16,

        NumberFormat_int32,

        NumberFormat_float,

        NumberFormat_ASCII

    };

    Ui::MainWindow *ui;

    QButtonGroup numberFormatButtons;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    unsigned int numOfChannels;

    QList<QwtPlotCurve*> curves;

    // Note: FrameBuffer s are owned by their respective QwtPlotCurve s.

    QList<FrameBuffer*> channelBuffers;

    // `data` contains i th channels data

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

    NumberFormat numberFormat;

    unsigned int sampleSize; // number of bytes in the selected number format

    double (MainWindow::*readSample)();

    // note that serialPort should already have enough bytes present

    template<typename T> double readSampleAs();

    bool skipByteRequested;

    const int SPS_UPDATE_TIMEOUT = 1;  // second

    QLabel spsLabel;

    unsigned int sampleCount;

    QTimer spsTimer;

    // snapshots

    QList<SnapShot*> snapshots;

    // demo

    QTimer demoTimer;

    int demoCount;

    bool isDemoRunning();

    QwtPlotTextLabel demoIndicator;

private slots:

    void onPortToggled(bool open);

    void onDataReady();      // used with binary number formats

    void onDataReadyASCII(); // used with ASCII number format

    void onPortError(QSerialPort::SerialPortError error);

    void skipByte();

    void onNumOfSamplesChanged(int value);

    void onAutoScaleChecked(bool checked);

    void onYScaleChanged();

    void onRangeSelected();

    void onNumOfChannelsChanged(int value);

    void onNumberFormatButtonToggled(int numberFormatId, bool checked);

    void selectNumberFormat(NumberFormat numberFormatId);

    void clearPlot();

    void spsTimerTimeout();

    void takeSnapShot();

    void demoTimerTimeout();

    void enableDemo(bool enabled);

    void onExportCsv();

};

#endif // MAINWINDOW_H

    replot();

}

void Plot::unzoomed()

{

    setAxisAutoScale(QwtPlot::xBottom);

    resetAxes();

}

void Plot::showGrid(bool show)

{

    grid.enableX(show);

    grid.enableY(show);

    replot();

}

void Plot::showMinorGrid(bool show)

{

    grid.enableXMin(show);

    grid.enableYMin(show);

    replot();

}

void Plot::unzoom()

{

    zoomer.zoom(0);

}

void Plot::darkBackground(bool enabled)

{

    if (enabled)

    {

        setCanvasBackground(QBrush(Qt::black));

        grid.setPen(Qt::darkGray);

        zoomer.setRubberBandPen(QPen(Qt::white));

        zoomer.setTrackerPen(QPen(Qt::white));

        sZoomer.setPickerPen(QPen(Qt::white));

    }

    else

    {

        setCanvasBackground(QBrush(Qt::white));

        grid.setPen(Qt::lightGray);

        zoomer.setRubberBandPen(QPen(Qt::black));

        zoomer.setTrackerPen(QPen(Qt::black));

        sZoomer.setPickerPen(QPen(Qt::black));

    }

    replot();

}

/*

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

*/

#ifndef PLOT_H

#define PLOT_H

#include <qwt_plot.h>

#include <qwt_plot_grid.h>

#include <qwt_plot_shapeitem.h>

#include "zoomer.h"

#include "scalezoomer.h"

class Plot : public QwtPlot

{

    Q_OBJECT

public:

    Plot(QWidget* parent = 0);

    void setAxis(bool autoScaled, double yMin = 0, double yMax = 1);

private:

    bool isAutoScaled;

    double yMin, yMax;

    Zoomer zoomer;

    ScaleZoomer sZoomer;

    QwtPlotGrid grid;

    QwtPlotShapeItem rectItem;

    void resetAxes();

public slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

private slots:

    void unzoomed();

};

#endif // PLOT_H

#include "snapshotview.h"

#include "ui_snapshotview.h"

SnapShotView::SnapShotView(QWidget *parent, SnapShot* snapShot) :

    QMainWindow(parent),

    ui(new Ui::SnapShotView)

{

    ui->setupUi(this);

    unsigned numOfChannels = snapShot->data.size();

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

    {

        QwtPlotCurve* curve = new QwtPlotCurve();

        curves.append(curve);

        curve->setSamples(snapShot->data[ci]);

        curve->attach(ui->plot);

    }

    _snapShot = snapShot;

}

SnapShotView::~SnapShotView()

{

    for (auto curve : curves)

    {

        delete curve;

    }

    delete ui;

}

#ifndef SNAPSHOTVIEW_H

#define SNAPSHOTVIEW_H

#include <QMainWindow>

#include <QVector>

#include <QPointF>

#include <qwt_plot_curve.h>

#include "plot.h"

class SnapShotView;

struct SnapShot

{

    QString name;

    QVector<QVector<QPointF>> data;

    SnapShotView* view;

};

namespace Ui {

class SnapShotView;

}

class SnapShotView : public QMainWindow

{

    Q_OBJECT

public:

    explicit SnapShotView(QWidget *parent, SnapShot* snapShot);

    ~SnapShotView();

private:

    Ui::SnapShotView *ui;

    QList<QwtPlotCurve*> curves;

    SnapShot* _snapShot;

};

#endif // SNAPSHOTVIEW_H