/*

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

#include <QModelIndex>

ChannelManager::ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent) :

    QObject(parent)

{

    _numOfChannels = numberOfChannels;

    _numOfSamples = numberOfSamples;

    QStringList channelNamesList;

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

    {

        channelBuffers.append(new FrameBuffer(numberOfSamples));

        channelNamesList << QString("Channel %1").arg(i+1);

    }

    _channelNames.setStringList(channelNamesList);

    connect(&_channelNames, &QStringListModel::dataChanged,

            this, &ChannelManager::onChannelNameDataChange);

}

ChannelManager::~ChannelManager()

{

    for (auto buffer : channelBuffers)

    {

        delete buffer;

    }

}

unsigned ChannelManager::numOfChannels()

{

    return channelBuffers.size();

}

unsigned ChannelManager::numOfSamples()

{

    return _numOfSamples;

}

void ChannelManager::setNumOfChannels(unsigned number)

{

    unsigned int oldNum = channelBuffers.size();

    if (number > oldNum)

    {

        // add new channels

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

        {

            channelBuffers.append(new FrameBuffer(_numOfSamples));

            addChannelName(QString("Channel %1").arg(oldNum+i+1));

        }

    }

    else if(number < oldNum)

    {

        // remove channels

        for (unsigned int i = oldNum-1; i > number-1; i--)

        {

            delete channelBuffers.takeLast();

            _channelNames.removeRow(i);

        }

    }

    emit numOfChannelsChanged(number);

}

void ChannelManager::setNumOfSamples(unsigned number)

{

    _numOfSamples = number;

    for (int ci = 0; ci < channelBuffers.size(); ci++)

    {

        channelBuffers[ci]->resize(_numOfSamples);

    }

    emit numOfSamplesChanged(number);

}

FrameBuffer* ChannelManager::channelBuffer(unsigned channel)

{

    return channelBuffers[channel];

}

QStringListModel* ChannelManager::channelNames()

{

    return &_channelNames;

}

QString ChannelManager::channelName(unsigned channel)

{

    return _channelNames.data(_channelNames.index(channel, 0), Qt::DisplayRole).toString();

}

void ChannelManager::setChannelName(unsigned channel, QString name)

{

    _channelNames.setData(_channelNames.index(channel, 0), QVariant(name), Qt::DisplayRole);

}

void ChannelManager::addChannelName(QString name)

{

    _channelNames.insertRow(_channelNames.rowCount());

    setChannelName(_channelNames.rowCount()-1, name);

}

void ChannelManager::onChannelNameDataChange(const QModelIndex & topLeft,

                                             const QModelIndex & bottomRight,

                                             const QVector<int> & roles)

{

    Q_UNUSED(roles);

    int start = topLeft.row();

    int end = bottomRight.row();

    // TODO: maybe check `roles` parameter, can't think of a reason for current use case

    for (int i = start; i <= end; i++)

    {

        emit channelNameChanged(i, channelName(i));

    }

}

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

{

    channelBuffer(channel)->addSamples(data, size);

}

/*

  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 CHANNELMANAGER_H

#define CHANNELMANAGER_H

#include <QObject>

#include <QStringListModel>

#include <QModelIndex>

#include <QVector>

#include "framebuffer.h"

class ChannelManager : public QObject

{

    Q_OBJECT

public:

    explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);

    ~ChannelManager();

    unsigned numOfChannels();

    unsigned numOfSamples();

    FrameBuffer* channelBuffer(unsigned channel);

    QStringListModel* channelNames();

    QString channelName(unsigned channel);

signals:

    void numOfChannelsChanged(unsigned value);

    void numOfSamplesChanged(unsigned value);

    void channelNameChanged(unsigned channel, QString name);

public slots:

    void setNumOfChannels(unsigned number);

    void setNumOfSamples(unsigned number);

    void setChannelName(unsigned channel, QString name);

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

private:

    unsigned _numOfChannels;

    unsigned _numOfSamples;

    QList<FrameBuffer*> channelBuffers;

    QStringListModel _channelNames;

    void addChannelName(QString name); ///< appends a new channel name at the end of list

private slots:

    void onChannelNameDataChange(const QModelIndex & topLeft,

                                 const QModelIndex & bottomRight,

                                 const QVector<int> & roles = QVector<int> ());

};

#endif // CHANNELMANAGER_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);

    dataFormatPanel.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

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

    // save panel minimization

    settings->setValue(SG_MainWindow_HidePanels,

                       ui->tabWidget->hideAction.isChecked());

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

    // hide panels

    ui->tabWidget->hideAction.setChecked(

        settings->value(SG_MainWindow_HidePanels,

                        ui->tabWidget->hideAction.isChecked()).toBool());

    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_Binary[] = "DataFormat_Binary";

const char SettingGroup_ASCII[] = "DataFormat_ASCII";

const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";

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

// ascii reader keys

const char SG_ASCII_NumOfChannels[] = "numOfChannels";

// framed reader keys

const char SG_CustomFrame_NumOfChannels[] = "numOfChannels";

const char SG_CustomFrame_FrameStart[] = "frameStart";

const char SG_CustomFrame_FixedSize[] = "fixedSize";

const char SG_CustomFrame_FrameSize[] = "frameSize";

const char SG_CustomFrame_NumberFormat[] = "numberFormat";

const char SG_CustomFrame_Endianness[] = "endianness";

const char SG_CustomFrame_Checksum[] = "checksum";

const char SG_CustomFrame_DebugMode[] = "debugMode";

#endif // SETTING_DEFINES_H