/*

  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;

    plotWidth = 1;

    showSymbols = Plot::ShowSymbolsAuto;

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

    // init no channels are visible indicator

    QwtText noChannelText(" No Visible Channels ");

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

    noChannelText.setBackgroundBrush(Qt::darkBlue);

    noChannelText.setBorderRadius(4);

    noChannelText.setRenderFlags(Qt::AlignHCenter | Qt::AlignVCenter);

    noChannelIndicator.setText(noChannelText);

    noChannelIndicator.hide();

    noChannelIndicator.attach(this);

}

Plot::~Plot()

{

    if (snapshotOverlay != NULL) delete snapshotOverlay;

}

void Plot::setDispChannels(QVector<const StreamChannel*> channels)

{

    zoomer.setDispChannels(channels);

}

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

{

    this->isAutoScaled = autoScaled;

    if (!autoScaled)

    {

        yMin = yAxisMin;

        yMax = yAxisMax;

    }

    zoomer.zoom(0);

    resetAxes();

}

void Plot::setXAxis(double xMin, double xMax)

{

    _xMin = xMin;

    _xMax = xMax;

    zoomer.setXLimits(xMin, xMax);

    // set axis

    // setAxisScale(QwtPlot::xBottom, xMin, xMax);

    replot(); // Note: if we don't replot here scale at startup isn't set correctly

    // reset zoom base

    // auto base = zoomer.zoomBase();

    // base.setLeft(xMin);

    // base.setRight(xMax);

    // zoomer.setZoomBase(base);

    onXScaleChanged();

}

void Plot::resetAxes()

{

    // reset y axis

    if (isAutoScaled)

    {

        setAxisAutoScale(QwtPlot::yLeft);

    }

    else

    {

        setAxisScale(QwtPlot::yLeft, yMin, yMax);

    }

    zoomer.setZoomBase();

    replot();

}

void Plot::unzoomed()

{

    resetAxes();

    onXScaleChanged();

}

void Plot::showGrid(bool show)

{

    grid.enableX(show);

    grid.enableY(show);

    replot();

}

void Plot::showMinorGrid(bool show)

{

    grid.enableXMin(show);

    grid.enableYMin(show);

    replot();

}

void Plot::showLegend(bool show)

{

    legend.setVisible(show);

    replot();

}

void Plot::showDemoIndicator(bool show)

{

    demoIndicator.setVisible(show);

    replot();

}

void Plot::showNoChannel(bool show)

{

    noChannelIndicator.setVisible(show);

    replot();

}

void Plot::unzoom()

{

    zoomer.zoom(0);

}

void Plot::darkBackground(bool enabled)

{

    QColor gridColor;

    if (enabled)

    {

        setCanvasBackground(QBrush(Qt::black));

        gridColor.setHsvF(0, 0, 0.25);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::white));

        zoomer.setTrackerPen(QPen(Qt::white));

        sZoomer.setPickerPen(QPen(Qt::white));

        legend.setTextPen(QPen(Qt::white));

    }

    else

    {

        setCanvasBackground(QBrush(Qt::white));

        gridColor.setHsvF(0, 0, 0.80);

        grid.setPen(gridColor);

        zoomer.setRubberBandPen(QPen(Qt::black));

        zoomer.setTrackerPen(QPen(Qt::black));

        sZoomer.setPickerPen(QPen(Qt::black));

        legend.setTextPen(QPen(Qt::black));

    }

    updateSymbols();

    replot();

}

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;

    if (showSymbols == Plot::ShowSymbolsAuto)

    {

        calcSymbolSize();

    }

    else if (showSymbols == Plot::ShowSymbolsShow)

    {

        symbolSize = SYMBOL_SIZE_MAX;

    }

    else

    {

        symbolSize = 0;

    }

    updateSymbols();

    replot();

}

void Plot::onXScaleChanged()

{

    if (showSymbols == Plot::ShowSymbolsAuto)

    {

        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 plotWidthNumSamp = abs(numOfSamples * plotWidth / (_xMax - _xMin));

    float samplesInView = plotWidthNumSamp / 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));

            }

/*

  Copyright © 2014 Uwe Rathmann

  This file is copied from Qwt project; you can redistribute it and/or modify it

  under the terms of the Qwt License, Version 1.0. You can obtain the original

  source code and the details of the Qwt License from the Qwt website:

  http://qwt.sourceforge.net/

*/

#include <qevent.h>

#include <qwt_plot_canvas.h>

#include <qwt_plot_layout.h>

#include <qwt_scale_engine.h>

#include <qwt_scale_widget.h>

#include "scrollbar.h"

#include "scrollzoomer.h"

class ScrollData

{

public:

    ScrollData():

        scrollBar( NULL ),

        position( ScrollZoomer::OppositeToScale ),

        mode( Qt::ScrollBarAsNeeded )

    {

    }

    ~ScrollData()

    {

        delete scrollBar;

    }

    ScrollBar *scrollBar;

    ScrollZoomer::ScrollBarPosition position;

    Qt::ScrollBarPolicy mode;

};

ScrollZoomer::ScrollZoomer( QWidget *canvas ):

    QwtPlotZoomer( canvas ),

    d_cornerWidget( NULL ),

    d_hScrollData( NULL ),

    d_vScrollData( NULL ),

    d_inZoom( false )

{

    xMin = 0.;

    xMax = 10000.;

    hViewSize = 10000;

    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

        d_alignCanvasToScales[ axis ] = false;

    if ( !canvas )

        return;

    d_hScrollData = new ScrollData;

    d_vScrollData = new ScrollData;

    hscrollmove = false;

    vscrollmove = false;

}

ScrollZoomer::~ScrollZoomer()

{

    delete d_cornerWidget;

    delete d_vScrollData;

    delete d_hScrollData;

}

void ScrollZoomer::setXLimits(double min, double max)

{

    xMin = min;

    xMax = max;

    setZoomBase();

}

void ScrollZoomer::setHViewSize(double size)

{

    hscrollmove = true;

    hViewSize = size;

    setZoomBase();

    hscrollmove = false;

}

void ScrollZoomer::setZoomBase(bool doReplot)

{

    QwtPlotZoomer::setZoomBase(doReplot);

    auto zb = zoomBase();

    auto zs = zoomStack();

    {

    }

    else

    {

    }

    zs[0] = zb;

    setZoomStack(zs);

}

void ScrollZoomer::rescale()

{

    QwtScaleWidget *xScale = plot()->axisWidget( xAxis() );

    QwtScaleWidget *yScale = plot()->axisWidget( yAxis() );

    if ( zoomRectIndex() <= 0 )

    {

        if ( d_inZoom )

        {

            xScale->setMinBorderDist( 0, 0 );

            yScale->setMinBorderDist( 0, 0 );

            QwtPlotLayout *layout = plot()->plotLayout();

            for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

                layout->setAlignCanvasToScale( axis, d_alignCanvasToScales[ axis ] );

            d_inZoom = false;

        }

    }

    else

    {

        if ( !d_inZoom )

        {

            /*

             We set a minimum border distance.

             Otherwise the canvas size changes when scrolling,

             between situations where the major ticks are at

             the canvas borders (requiring extra space for the label)

             and situations where all labels can be painted below/top

             or left/right of the canvas.

             */

            int start, end;

            xScale->getBorderDistHint( start, end );

            xScale->setMinBorderDist( start, end );

            yScale->getBorderDistHint( start, end );

            yScale->setMinBorderDist( start, end );

            QwtPlotLayout *layout = plot()->plotLayout();

            for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )

            {

                d_alignCanvasToScales[axis] = 

                    layout->alignCanvasToScale( axis );

            }

            layout->setAlignCanvasToScales( false );

            d_inZoom = true;

        }

    }

    // NOTE: Below snippet is copied from QwtPlotZoomer::rescale() just so that

    // we can refrain from updating y axis when moving horizontal scrollbar, so

    // that auto-scale isn't disrupted. Also we don't want to jump around in

    // x-axis when moving vertical scroll.

    {

        QwtPlot *plt = plot();

        if ( !plt )

            return;

        const QRectF &rect = zoomStack()[zoomRectIndex()];

        if ( rect != scaleRect() )

        {

            const bool doReplot = plt->autoReplot();

            plt->setAutoReplot( false );

            if (!vscrollmove)

            {

                double x1 = rect.left();

                double x2 = rect.right();

                if ( !plt->axisScaleDiv( xAxis() ).isIncreasing() )

                    qSwap( x1, x2 );

                plt->setAxisScale( xAxis(), x1, x2 );

            }

            if (!hscrollmove)

            {

                double y1 = rect.top();

                double y2 = rect.bottom();

                if ( !plt->axisScaleDiv( yAxis() ).isIncreasing() )

                    qSwap( y1, y2 );

                plt->setAxisScale( yAxis(), y1, y2 );

                plt->setAutoReplot( doReplot );

            }

            plt->replot();

        }

    }

    updateScrollBars();

}

ScrollBar *ScrollZoomer::scrollBar( Qt::Orientation orientation )

{

    ScrollBar *&sb = ( orientation == Qt::Vertical )

        ? d_vScrollData->scrollBar : d_hScrollData->scrollBar;

    if ( sb == NULL )

    {

        sb = new ScrollBar( orientation, canvas() );

        sb->hide();

        connect( sb,

            SIGNAL( valueChanged( Qt::Orientation, double, double ) ),

            SLOT( scrollBarMoved( Qt::Orientation, double, double ) ) );

    }

    return sb;

}

ScrollBar *ScrollZoomer::horizontalScrollBar() const

{

    return d_hScrollData->scrollBar;

}

ScrollBar *ScrollZoomer::verticalScrollBar() const

{

    return d_vScrollData->scrollBar;

}

void ScrollZoomer::setHScrollBarMode( Qt::ScrollBarPolicy mode )

{

    if ( hScrollBarMode() != mode )

    {

        d_hScrollData->mode = mode;

        updateScrollBars();

    }

}

void ScrollZoomer::setVScrollBarMode( Qt::ScrollBarPolicy mode )

{

    if ( vScrollBarMode() != mode )

    {

        d_vScrollData->mode = mode;

        updateScrollBars();

    }

}

Qt::ScrollBarPolicy ScrollZoomer::hScrollBarMode() const

{

    return d_hScrollData->mode;

}

Qt::ScrollBarPolicy ScrollZoomer::vScrollBarMode() const

{

    return d_vScrollData->mode;

}

void ScrollZoomer::setHScrollBarPosition( ScrollBarPosition pos )

{

    if ( d_hScrollData->position != pos )

    {

        d_hScrollData->position = pos;

        updateScrollBars();

    }

}

void ScrollZoomer::setVScrollBarPosition( ScrollBarPosition pos )

{

    if ( d_vScrollData->position != pos )

    {

        d_vScrollData->position = pos;

        updateScrollBars();

    }

}

ScrollZoomer::ScrollBarPosition ScrollZoomer::hScrollBarPosition() const

{

    return d_hScrollData->position;

}

ScrollZoomer::ScrollBarPosition ScrollZoomer::vScrollBarPosition() const

{

    return d_vScrollData->position;

}

void ScrollZoomer::setCornerWidget( QWidget *w )

{

    if ( w != d_cornerWidget )

    {

        if ( canvas() )

        {

            delete d_cornerWidget;

            d_cornerWidget = w;

            if ( d_cornerWidget->parent() != canvas() )

                d_cornerWidget->setParent( canvas() );

/*

  Copyright © 2014 Uwe Rathmann

  This file is copied from Qwt project; you can redistribute it and/or modify it

  under the terms of the Qwt License, Version 1.0. You can obtain the original

  source code and the details of the Qwt License from the Qwt website:

  http://qwt.sourceforge.net/

*/

#ifndef _SCROLLZOOMER_H

#define _SCROLLZOOMER_H

#include <qglobal.h>

#include <qwt_plot_zoomer.h>

#include <qwt_plot.h>

class ScrollData;

class ScrollBar;

class ScrollZoomer: public QwtPlotZoomer

{

    Q_OBJECT

public:

    enum ScrollBarPosition

    {

        AttachedToScale,

        OppositeToScale

    };

    ScrollZoomer( QWidget * );

    virtual ~ScrollZoomer();

    ScrollBar *horizontalScrollBar() const;

    ScrollBar *verticalScrollBar() const;

    void setHScrollBarMode( Qt::ScrollBarPolicy );

    void setVScrollBarMode( Qt::ScrollBarPolicy );

    Qt::ScrollBarPolicy vScrollBarMode () const;

    Qt::ScrollBarPolicy hScrollBarMode () const;

    void setHScrollBarPosition( ScrollBarPosition );

    void setVScrollBarPosition( ScrollBarPosition );

    ScrollBarPosition hScrollBarPosition() const;

    ScrollBarPosition vScrollBarPosition() const;

    QWidget* cornerWidget() const;

    virtual void setCornerWidget( QWidget * );

    virtual bool eventFilter( QObject *, QEvent * );

    void setXLimits(double min, double max);

    void setHViewSize(double size);

    virtual void setZoomBase(bool doReplot = true);

    virtual void rescale();

public Q_SLOTS:

    virtual void moveTo( const QPointF & );

protected:

    virtual ScrollBar *scrollBar( Qt::Orientation );

    virtual void updateScrollBars();

    virtual void layoutScrollBars( const QRect & );

private Q_SLOTS:

    void scrollBarMoved( Qt::Orientation o, double min, double max );

private:

    QRectF d_limits;

    double xMin, xMax;

    double hViewSize;

    bool needScrollBar( Qt::Orientation ) const;

    int oppositeAxis( int ) const;

    QWidget *d_cornerWidget;

    ScrollData *d_hScrollData;

    ScrollData *d_vScrollData;

    bool d_inZoom;

    bool d_alignCanvasToScales[ QwtPlot::axisCnt ];

    bool hscrollmove;

    bool vscrollmove;

};

#endif