/*

  Copyright © 2017 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 <QModelIndex>

#include <QtDebug>

#include "channelmanager.h"

#include "setting_defines.h"

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

    QObject(parent),

    _infoModel(numberOfChannels)

{

    _numOfChannels = numberOfChannels;

    _numOfSamples = numberOfSamples;

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

    {

        channelBuffers.append(new FrameBuffer(numberOfSamples));

    }

    connect(&_infoModel, &ChannelInfoModel::dataChanged,

            this, &ChannelManager::onChannelInfoChanged);

}

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

        }

    }

    else if(number < oldNum)

    {

        // remove channels

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

        {

            delete channelBuffers.takeLast();

        }

    }

    _infoModel.setNumOfChannels(number);

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

}

ChannelInfoModel* ChannelManager::infoModel()

{

    return &_infoModel;

}

QString ChannelManager::channelName(unsigned channel)

{

    return _infoModel.data(_infoModel.index(channel, ChannelInfoModel::COLUMN_NAME),

                           Qt::DisplayRole).toString();

}

QStringList ChannelManager::channelNames()

{

    QStringList list;

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

    {

        list << channelName(ci);

    }

    return list;

}

void ChannelManager::onChannelInfoChanged(const QModelIndex & topLeft,

                                          const QModelIndex & bottomRight,

                                          const QVector<int> & roles)

{

    int start = topLeft.row();

    int end = bottomRight.row();

    int col = topLeft.column();

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

    {

        for (auto role : roles)

        {

            switch (role)

            {

                case Qt::EditRole:

                    if (col == ChannelInfoModel::COLUMN_NAME)

                    {

                        emit channelNameChanged(ci, channelName(ci));

                    }

                    break;

                case Qt::ForegroundRole:

                    if (col == ChannelInfoModel::COLUMN_NAME)

                    {

                        // TODO: emit channel color changed

                    }

                    break;

                case Qt::CheckStateRole:

                    if (col == ChannelInfoModel::COLUMN_VISIBILITY)

                    {

                        // TODO: emit visibility

                    }

                    break;

            }

        }

        // emit channelNameChanged(i, channelName(i));

    }

}

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

{

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

}

void ChannelManager::saveSettings(QSettings* settings)

{

    _infoModel.saveSettings(settings);

}

void ChannelManager::loadSettings(QSettings* settings)

{

    _infoModel.loadSettings(settings);

}

}

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)

    {

#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))

        case QtInfoMsg:

            logString = "[Info] " + msg;

            break;

#endif

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

    channelMan.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

    plotMan->saveSettings(settings);

    commandPanel.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    channelMan.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

    plotMan->loadSettings(settings);

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

    // save window maximized state

    settings->setValue(SG_MainWindow_Maximized,

                       bool(windowState() & Qt::WindowMaximized));

    // save toolbar/dockwidgets state

    settings->setValue(SG_MainWindow_State, saveState());

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

    // maximize window

    if (settings->value(SG_MainWindow_Maximized).toBool())

    {

        showMaximized();

    }

    // load toolbar/dockwidgets state

    restoreState(settings->value(SG_MainWindow_State).toByteArray());

    settings->setValue(SG_MainWindow_State, saveState());

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