#include <QFile>

#include <QTextStream>

#include <QtDebug>

#include <QtEndian>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include <snapshotview.h>

#include <plot.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);

                     });

    ui->actionMinorGrid->setEnabled(ui->actionGrid->isChecked());

    QObject::connect(ui->actionMinorGrid, &QAction::toggled,

                     ui->plot, &Plot::showMinorGrid);

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

                     ui->plot, &Plot::unzoom);

    QObject::connect(ui->actionDarkBackground, &QAction::toggled,

                     ui->plot, &Plot::darkBackground);

    ui->plot->darkBackground(ui->actionDarkBackground->isChecked());

    // port control signals

    QObject::connect(&portControl, &PortControl::portToggled,

                     this, &MainWindow::onPortToggled);

    QObject::connect(&portControl, &PortControl::skipByteRequested,

                     this, &MainWindow::skipByte);

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

                     this, &MainWindow::onNumOfSamplesChanged);

    QObject::connect(ui->cbAutoScale, &QCheckBox::toggled,

                     this, &MainWindow::onAutoScaleChecked);

    QObject::connect(ui->spYmin, SIGNAL(valueChanged(double)),

                     this, SLOT(onYScaleChanged()));

    QObject::connect(ui->spYmax, SIGNAL(valueChanged(double)),

                     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]->setPen(Plot::makeColor(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;

    spsLabel.setText("0sps");

    spsLabel.setToolTip("samples per second (total of all channels)");

    ui->statusBar->addPermanentWidget(&spsLabel);

    spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);

    QObject::connect(&spsTimer, &QTimer::timeout,

                     this, &MainWindow::spsTimerTimeout);

    }

    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;

    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::takeSnapShot()

{

    qDebug() << "taking a snopshot yay!";

    auto snapShot = new SnapShot(this, "New Snapshot");

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

    {

        snapShot->data.append(QVector<QPointF>(numOfSamples));

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

        {

            snapShot->data[ci][i] = channelBuffers[ci]->sample(i);

        }

    }

    snapshots.append(snapShot);

    updateSnapShotMenu();

}

void MainWindow::updateSnapShotMenu()

{

    ui->menuSnapShots->clear();

    ui->menuSnapShots->addAction(ui->actionSnapShot);

    if (snapshots.size())

    {

        ui->menuSnapShots->addSeparator();

        for (auto ss : snapshots)

        {

            ui->menuSnapShots->addAction(ss->menuAction());

        }

        ui->menuSnapShots->addSeparator();

        ui->menuSnapShots->addAction(ui->actionClearSnapShots);

    }

}

#include "framebuffer.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    void messageHandler(QtMsgType type, const QMessageLogContext &context,

                        const QString &msg);

private:

    enum NumberFormat

    {

        NumberFormat_uint8,

        NumberFormat_uint16,

        NumberFormat_uint32,

        NumberFormat_int8,

        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;

    void updateSnapShotMenu();

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