/*

  Copyright © 2018 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 <QVariant>

#include <QMessageBox>

#include <QCheckBox>

#include <math.h>

#include "color_selector.hpp"

#include "plotcontrolpanel.h"

#include "ui_plotcontrolpanel.h"

#include "setting_defines.h"

/// Confirm if #samples is being set to a value greater than this

const int NUMSAMPLES_CONFIRM_AT = 1000000;

/// Used for scale range selection combobox

struct Range

{

    double rmin;

    double rmax;

};

Q_DECLARE_METATYPE(Range);

PlotControlPanel::PlotControlPanel(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::PlotControlPanel),

    resetAct(tr("Reset"), this),

    resetNamesAct(tr("Reset Names"), this),

    resetColorsAct(tr("Reset Colors"), this),

    showAllAct(tr("Show All"), this),

    hideAllAct(tr("Hide All"), this),

    resetMenu(tr("Reset Menu"), this)

{

    ui->setupUi(this);

    warnNumOfSamples = true;    // TODO: load from settings

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

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

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

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

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

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

    // connect signals

    connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

            this, SLOT(onNumOfSamples(int)));

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

            this, &PlotControlPanel::onAutoScaleChecked);

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

            this, SLOT(onYScaleChanged()));

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

            this, SLOT(onYScaleChanged()));

    connect(ui->cbIndex, &QCheckBox::toggled,

            this, &PlotControlPanel::onIndexChecked);

    connect(ui->spXmax, SIGNAL(valueChanged(double)),

            this, SLOT(onXScaleChanged()));

    connect(ui->spXmax, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),

            [this](double v)

            {

                // set limit just a little below

                double step = pow(10, -1 * ui->spXmin->decimals());

                ui->spXmin->setMaximum(v - step);

            });

    connect(ui->spXmin, SIGNAL(valueChanged(double)),

            this, SLOT(onXScaleChanged()));

    connect(ui->spXmin, static_cast<void(QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),

            [this](double v)

            {

                // set limit just a little above

                double step = pow(10, -1 * ui->spXmax->decimals());

                ui->spXmax->setMinimum(v + step);

            });

    connect(ui->spPlotWidth, SIGNAL(valueChanged(int)),

            this, SLOT(onPlotWidthChanged()));

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

    // color selector starts disabled until a channel is selected

    ui->colorSelector->setColor(QColor(0,0,0,0));

    ui->colorSelector->setDisplayMode(color_widgets::ColorPreview::AllAlpha);

    ui->colorSelector->setDisabled(true);

    // reset buttons

    resetAct.setToolTip(tr("Reset channel names and colors"));

    resetMenu.addAction(&resetNamesAct);

    resetMenu.addAction(&resetColorsAct);

    resetAct.setMenu(&resetMenu);

    ui->tbReset->setDefaultAction(&resetAct);

    showAllAct.setToolTip(tr("Show all channels"));

    hideAllAct.setToolTip(tr("Hide all channels"));

    ui->tbShowAll->setDefaultAction(&showAllAct);

    ui->tbHideAll->setDefaultAction(&hideAllAct);

}

PlotControlPanel::~PlotControlPanel()

{

    delete ui;

}

unsigned PlotControlPanel::numOfSamples()

{

    return ui->spNumOfSamples->value();

}

void PlotControlPanel::onNumOfSamples(int value)

{

    if (warnNumOfSamples && value > NUMSAMPLES_CONFIRM_AT)

    {

        // ask confirmation

        if (!askNSConfirmation(value))

        {

            // revert to old value

            disconnect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

                       this, SLOT(onNumOfSamples(int)));

            ui->spNumOfSamples->setValue(_numOfSamples);

            connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

                    this, SLOT(onNumOfSamples(int)));

            return;

        }

    }

    _numOfSamples = value;

    emit numOfSamplesChanged(value);

}

bool PlotControlPanel::askNSConfirmation(int value)

{

    auto text = tr("Setting number of samples to a too big value "

                   "(>%1) can seriously impact the performance of "

                   "the application and cause freezes. Are you sure you "

                   "want to change the number of samples to %2?")

        .arg(QString::number(NUMSAMPLES_CONFIRM_AT), QString::number(value));

    // TODO: parent the mainwindow

    QMessageBox mb(QMessageBox::Warning,

                   tr("Confirm Number of Samples"),

                   text,

                   QMessageBox::Apply | QMessageBox::Cancel,

                   this);

    auto cb = new QCheckBox("Don't show this again.");

    connect(cb, &QCheckBox::stateChanged, [this](int state)

            {

                warnNumOfSamples = (state == Qt::Unchecked);

            });

    mb.setCheckBox(cb);

    return mb.exec() == QMessageBox::Apply;

}

void PlotControlPanel::onAutoScaleChecked(bool checked)

{

    if (checked)

    {

        ui->lYmin->setEnabled(false);

        ui->lYmax->setEnabled(false);

        ui->spYmin->setEnabled(false);

        ui->spYmax->setEnabled(false);

        emit yScaleChanged(true); // autoscale

    }

    else

    {

        ui->lYmin->setEnabled(true);

        ui->lYmax->setEnabled(true);

        ui->spYmin->setEnabled(true);

        ui->spYmax->setEnabled(true);

        emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());

    }

}

void PlotControlPanel::onYScaleChanged()

{

    if (!autoScale())

    {

        emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());

    }

}

bool PlotControlPanel::autoScale() const

{

/*

  Copyright © 2018 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 PLOTCONTROLPANEL_H

#define PLOTCONTROLPANEL_H

#include <QWidget>

#include <QSettings>

#include <QAction>

#include <QMenu>

#include "channelinfomodel.h"

namespace Ui {

class PlotControlPanel;

}

class PlotControlPanel : public QWidget

{

    Q_OBJECT

public:

    explicit PlotControlPanel(QWidget *parent = 0);

    ~PlotControlPanel();

    unsigned numOfSamples();

    bool   autoScale() const;

    double yMax() const;

    double yMin() const;

    bool   xAxisAsIndex() const;

    double xMax() const;

    double xMin() const;

    /// Returns the plot width adjusted for x axis scaling.

    double plotWidth() const;

    void setChannelInfoModel(ChannelInfoModel* model);

    /// Stores plot settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads plot settings from a `QSettings`.

    void loadSettings(QSettings* settings);

signals:

    void numOfSamplesChanged(int value);

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

    void xScaleChanged(bool asIndex, double xMin = 0, double xMax = 1);

    void plotWidthChanged(double width);

private:

    Ui::PlotControlPanel *ui;

    /// Holds 'number of samples' after the confirmation

    unsigned _numOfSamples;

    /// User can disable this setting in the checkbox

    bool warnNumOfSamples;

    QAction resetAct, resetNamesAct, resetColorsAct, showAllAct, hideAllAct;

    QMenu resetMenu;

    /// Show a confirmation dialog before setting #samples to a big value

    bool askNSConfirmation(int value);

private slots:

    void onNumOfSamples(int value);

    void onAutoScaleChecked(bool checked);

    void onYScaleChanged();

    void onRangeSelected();

    void onIndexChecked(bool checked);

    void onXScaleChanged();

    void onPlotWidthChanged();

};

#endif // PLOTCONTROLPANEL_H