/*

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

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

                     this, SLOT(clearSnapshots()));

    // setup number of channels spinbox

        {

            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;

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

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

    }

}

void MainWindow::clearSnapshots()

{

    for (auto snapshot : snapshots)

    {

        delete snapshot;

    }

    snapshots.clear();

    updateSnapShotMenu();

}