/*

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

#include <QKeySequence>

#include <QColor>

#include <qwt_symbol.h>

#include <qwt_plot_curve.h>

#include <math.h>

#include <algorithm>

#include "plot.h"

#include "utils.h"

static const int SYMBOL_SHOW_AT_WIDTH = 5;

static const int SYMBOL_SIZE_MAX = 7;

Plot::Plot(QWidget* parent) :

    QwtPlot(parent),

    zoomer(this->canvas(), false),

    sZoomer(this, &zoomer)

{

    isAutoScaled = true;

    symbolSize = 0;

    numOfSamples = 1;

    QObject::connect(&zoomer, &Zoomer::unzoomed, this, &Plot::unzoomed);

    zoomer.setZoomBase();

    grid.attach(this);

    legend.attach(this);

    showGrid(false);

    darkBackground(false);

    snapshotOverlay = NULL;

    connect(&zoomer, &QwtPlotZoomer::zoomed,

            [this](const QRectF &rect)

            {

                onXScaleChanged();

            });

    connect(this, &QwtPlot::itemAttached,

            [this](QwtPlotItem *plotItem, bool on)

            {

                if (symbolSize) updateSymbols();

            });

    // init demo indicator

    QwtText demoText(" DEMO RUNNING ");  // looks better with spaces

    demoText.setColor(QColor("white"));

    demoText.setBackgroundBrush(Qt::darkRed);

    demoText.setBorderRadius(4);

    demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignBottom);

    demoIndicator.setText(demoText);

    demoIndicator.hide();

    demoIndicator.attach(this);

}

Plot::~Plot()

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

}

void Plot::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)

{

    this->isAutoScaled = autoScaled;

    if (!autoScaled)

    {

        yMin = yAxisMin;

        yMax = yAxisMax;

  o -> 8-15

  . -> 16-31

 */

QColor Plot::makeColor(unsigned int channelIndex)

{

    auto i = channelIndex;

    if (i < 4)

    {

        return QColor::fromHsv(360*i/4, 255, 230);

    }

    else

    {

        double p = floor(log2(i));

        double n = pow(2, p);

        i = i - n;

        return QColor::fromHsv(360*i/n + 360/pow(2,p+1), 255, 230);

    }

}

void Plot::flashSnapshotOverlay(bool light)

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

    QColor color;

    if(light)

    {

        color = QColor(Qt::white);

    }

    else

    {

        color = QColor(Qt::black);

    }

    snapshotOverlay = new PlotSnapshotOverlay(this->canvas(), color);

    connect(snapshotOverlay, &PlotSnapshotOverlay::done,

            [this]()

            {

                delete snapshotOverlay;

                snapshotOverlay = NULL;

            });

}

void Plot::setSymbols(ShowSymbols shown)

{

    showSymbols = shown;

    {

        calcSymbolSize();

    }

    {

        symbolSize = SYMBOL_SIZE_MAX;

    }

    else

    {

        symbolSize = 0;

    }

    updateSymbols();

    replot();

}

void Plot::onXScaleChanged()

{

    {

        calcSymbolSize();

        updateSymbols();

    }

}

void Plot::calcSymbolSize()

{

    auto sw = axisWidget(QwtPlot::xBottom);

    auto paintDist = sw->scaleDraw()->scaleMap().pDist();

    auto scaleDist = sw->scaleDraw()->scaleMap().sDist();

    auto fullScaleDist = zoomer.zoomBase().width();

    auto zoomRate = fullScaleDist / scaleDist;

    float samplesInView = numOfSamples / zoomRate;

    int symDisPx = round(paintDist / samplesInView);

    if (symDisPx < SYMBOL_SHOW_AT_WIDTH)

    {

        symbolSize = 0;

    }

    else

    {

        symbolSize = std::min(SYMBOL_SIZE_MAX, symDisPx-SYMBOL_SHOW_AT_WIDTH+1);

    }

}

void Plot::updateSymbols()

{

    const QwtPlotItemList curves = itemList( QwtPlotItem::Rtti_PlotCurve );

    if (curves.size() > 0)

    {

        for (int i = 0; i < curves.size(); i++)

        {

            QwtSymbol* symbol = NULL;

            QwtPlotCurve* curve = static_cast<QwtPlotCurve*>(curves[i]);

            if (symbolSize)

            {

                symbol = new QwtSymbol(QwtSymbol::Ellipse,

                                       canvasBackground(),

                                       curve->pen(),

                                       QSize(symbolSize, symbolSize));

            }

            curve->setSymbol(symbol);

        }

    }

}

/*

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

*/

#ifndef PLOT_H

#define PLOT_H

#include <QColor>

#include <QList>

#include <QAction>

#include <qwt_plot.h>

#include <qwt_plot_grid.h>

#include <qwt_plot_shapeitem.h>

#include <qwt_plot_legenditem.h>

#include <qwt_plot_textlabel.h>

#include "zoomer.h"

#include "scalezoomer.h"

#include "plotsnapshotoverlay.h"

class Plot : public QwtPlot

{

    Q_OBJECT

    friend class PlotManager;

public:

    enum ShowSymbols

    {

    };

    Plot(QWidget* parent = 0);

    ~Plot();

    static QColor makeColor(unsigned int channelIndex);

public slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void showDemoIndicator(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

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

    void setXAxis(double xMin, double xMax);

    void setSymbols(ShowSymbols shown);

    /**

     * Displays an animation for snapshot.

     *

     * @param light show a light colored (white) animation or the opposite

     */

    void flashSnapshotOverlay(bool light);

    void setNumOfSamples(unsigned value);

protected:

    /// update the display of symbols depending on `symbolSize`

    void updateSymbols();

private:

    bool isAutoScaled;

    double yMin, yMax;

    double _xMin, _xMax;

    unsigned numOfSamples;

    int symbolSize;

    Zoomer zoomer;

    ScaleZoomer sZoomer;

    QwtPlotGrid grid;

    PlotSnapshotOverlay* snapshotOverlay;

    QwtPlotLegendItem legend;

    QwtPlotTextLabel demoIndicator;

    ShowSymbols showSymbols;

    void resetAxes();

    void resizeEvent(QResizeEvent * event);

    void calcSymbolSize();

/*

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

#include <QMetaEnum>

#include <QtDebug>

#include "qwt_symbol.h"

#include "plot.h"

#include "plotmanager.h"

#include "utils.h"

#include "setting_defines.h"

PlotManager::PlotManager(QWidget* plotArea, ChannelInfoModel* infoModel, QObject *parent) :

    QObject(parent),

    _plotArea(plotArea),

    showGridAction("&Grid", this),

    showMinorGridAction("&Minor Grid", this),

    unzoomAction("&Unzoom", this),

    darkBackgroundAction("&Dark Background", this),

    showLegendAction("&Legend", this),

    showMultiAction("Multi &Plot", this),

    setSymbolsAction("Symbols", this)

{

    _autoScaled = true;

    _yMin = 0;

    _yMax = 1;

    isDemoShown = false;

    _infoModel = infoModel;

    _numOfSamples = 1;

    // initalize layout and single widget

    isMulti = false;

    scrollArea = NULL;

    setupLayout(isMulti);

    addPlotWidget();

    // initialize menu actions

    showGridAction.setToolTip("Show Grid");

    showMinorGridAction.setToolTip("Show Minor Grid");

    unzoomAction.setToolTip("Unzoom the Plot");

    darkBackgroundAction.setToolTip("Enable Dark Plot Background");

    showLegendAction.setToolTip("Display the Legend on Plot");

    showMultiAction.setToolTip("Display All Channels Separately");

    setSymbolsAction.setToolTip("Show/Hide symbols");

    showGridAction.setShortcut(QKeySequence("G"));

    showMinorGridAction.setShortcut(QKeySequence("M"));

    showGridAction.setCheckable(true);

    showMinorGridAction.setCheckable(true);

    darkBackgroundAction.setCheckable(true);

    showLegendAction.setCheckable(true);

    showMultiAction.setCheckable(true);

    showGridAction.setChecked(false);

    showMinorGridAction.setChecked(false);

    darkBackgroundAction.setChecked(false);

    showLegendAction.setChecked(true);

    showMultiAction.setChecked(false);

    showMinorGridAction.setEnabled(false);

    // setup symbols menu

            [this](bool checked)

            {

            });

            [this](bool checked)

            {

            });

            [this](bool checked)

            {

            });

    setSymbolsAction.setMenu(&setSymbolsMenu);

    // add symbol actions to same group so that they appear as radio buttons

    auto group = new QActionGroup(this);

    connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showGrid);

    connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            &showMinorGridAction, &QAction::setEnabled);

    connect(&showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showMinorGrid);

    connect(&unzoomAction, &QAction::triggered, this, &PlotManager::unzoom);

    connect(&darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::darkBackground);

    connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showLegend);

    connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::showLegend);

    connect(&showMultiAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

            this, &PlotManager::setMulti);

    // connect to channel info model

    if (_infoModel != NULL)     // TODO: remove when snapshots have infomodel

    {

        connect(_infoModel, &QAbstractItemModel::dataChanged,

                this, &PlotManager::onChannelInfoChanged);

        connect(_infoModel, &QAbstractItemModel::modelReset,

                [this]()

                {

                    onChannelInfoChanged(_infoModel->index(0, 0), // start

                                         _infoModel->index(_infoModel->rowCount()-1, 0), // end

                                         {}); // roles ignored

                });

    }

}

PlotManager::~PlotManager()

{

    while (curves.size())

    {

        delete curves.takeLast();

    }

    // remove all widgets

    while (plotWidgets.size())

    {

        delete plotWidgets.takeLast();

    }

    if (scrollArea != NULL) delete scrollArea;

}

    _xMin = xMin;

    _xMax = xMax;

    for (auto curve : curves)

    {

        // TODO: what happens when addCurve(QVector) is used?

        FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());

        series->setXAxis(asIndex, xMin, xMax);

    }

    for (auto plot : plotWidgets)

    {

        if (asIndex)

        {

            plot->setXAxis(0, _numOfSamples);

        }

        else

        {

            plot->setXAxis(xMin, xMax);

        }

    }

    replot();

}

void PlotManager::flashSnapshotOverlay()

{

    for (auto plot : plotWidgets)

    {

        plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());

    }

}

void PlotManager::onNumOfSamplesChanged(unsigned value)

{

    _numOfSamples = value;

    for (auto plot : plotWidgets)

    {

        plot->setNumOfSamples(value);

        if (_xAxisAsIndex) plot->setXAxis(0, value);

    }

}

void PlotManager::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    settings->setValue(SG_Plot_DarkBackground, darkBackgroundAction.isChecked());

    settings->setValue(SG_Plot_Grid, showGridAction.isChecked());

    settings->setValue(SG_Plot_MinorGrid, showMinorGridAction.isChecked());

    settings->setValue(SG_Plot_Legend, showLegendAction.isChecked());

    settings->setValue(SG_Plot_MultiPlot, showMultiAction.isChecked());

    settings->endGroup();

}

void PlotManager::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    darkBackgroundAction.setChecked(

        settings->value(SG_Plot_DarkBackground, darkBackgroundAction.isChecked()).toBool());

    darkBackground(darkBackgroundAction.isChecked());

    showGridAction.setChecked(

        settings->value(SG_Plot_Grid, showGridAction.isChecked()).toBool());

    showGrid(showGridAction.isChecked());

    showMinorGridAction.setChecked(

        settings->value(SG_Plot_MinorGrid, showMinorGridAction.isChecked()).toBool());

    showMinorGridAction.setEnabled(showGridAction.isChecked());

    showMinorGrid(showMinorGridAction.isChecked());

    showLegendAction.setChecked(

        settings->value(SG_Plot_Legend, showLegendAction.isChecked()).toBool());

    showLegend(showLegendAction.isChecked());

    showMultiAction.setChecked(

        settings->value(SG_Plot_MultiPlot, showMultiAction.isChecked()).toBool());

    setMulti(showMultiAction.isChecked());

    {

        {

            }

            else

            {

    }

    settings->endGroup();

}

    /// Stores plot settings into a `QSettings`.

    void saveSettings(QSettings* settings);

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

    void loadSettings(QSettings* settings);

public slots:

    /// Enable/Disable multiple plot display

    void setMulti(bool enabled);

    /// Update all plot widgets

    void replot();

    /// Enable display of a "DEMO" label on each plot

    void showDemoIndicator(bool show = true);

    /// Set the Y axis

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

    /// Set the X axis

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

    /// Display an animation for snapshot

    void flashSnapshotOverlay();

    /// Should be called to update zoom base

    void onNumOfSamplesChanged(unsigned value);

private:

    bool isMulti;

    QWidget* _plotArea;

    QVBoxLayout* layout; ///< layout of the `plotArea`

    QScrollArea* scrollArea;

    QList<QwtPlotCurve*> curves;

    QList<Plot*> plotWidgets;

    ChannelInfoModel* _infoModel;

    bool isDemoShown;

    bool _autoScaled;

    double _yMin;

    double _yMax;

    bool _xAxisAsIndex;

    double _xMin;

    double _xMax;

    unsigned _numOfSamples;

    Plot::ShowSymbols showSymbols;

    // menu actions

    QAction showGridAction;

    QAction showMinorGridAction;

    QAction unzoomAction;

    QAction darkBackgroundAction;

    QAction showLegendAction;

    QAction showMultiAction;

    QAction setSymbolsAction;

    QMenu setSymbolsMenu;

    void setupLayout(bool multiPlot);

    /// Inserts a new plot widget to the current layout.

    Plot* addPlotWidget();

    /// Returns the plot widget that given curve is attached to

    Plot* plotWidget(unsigned curveIndex);

    /// Common part of overloaded `addCurve` functions

    void _addCurve(QwtPlotCurve* curve);

    void setSymbols(Plot::ShowSymbols shown);

private slots:

    void showGrid(bool show = true);

    void showMinorGrid(bool show = true);

    void showLegend(bool show = true);

    void unzoom();

    void darkBackground(bool enabled = true);

    void onChannelInfoChanged(const QModelIndex & topLeft,

                              const QModelIndex & bottomRight,

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

};

#endif // PLOTMANAGER_H