#ifndef PLOTFUNCTION_HH_
#define PLOTFUNCTION_HH_

// includes boost
#include <boost/shared_ptr.hpp>

#include "NodeCfg.hh"
#include "PanelPlotOutput.hh"
#include "PlPlotUtil.hh"
#include "PlotFunctionNode.hh"
#include "plotFunctionElements/Abscisse.hh"
#include <climits>

#include "DefaultTimeAxisDecorator.hh"

#include "TimeAxisDecorator.hh"

#include "plplot/plplot.h"
#include "plplot/plplotP.h"
#include "plplot/plstream.h"
#include <map>

#include "plplot/plstream.h"

extern "C"
{
#include <plplot/qsastime.h>
}

/**
 * @brief Id pour l'axe X qui sera crée
 *
 */

#define X_AXIS_ID "x_axis_id"

/**
 * @brief Id pour l'axe Y qui sera crée
 *
 */

#define Y_AXIS_ID ""

namespace plot
{

    class PlotFunction : public PanelPlotOutput
    {
    public:

        /**
         * @brief enum to represent the type of fucntion to apply for plotfunction feature
         *
         */

        enum Function
        {
            NONE,

            AVG,

            FFT,
            SUM
        };

        PlotFunction(AMDA::Parameters::ParameterManager &manager,
                     boost::shared_ptr<Panel> panel, TimeAxisDecorator *timeAxisDecorator = new DefaultTimeAxisDecorator());
        virtual ~PlotFunction();

        /**
         * @overload plot::PanelPlotOutput
         */
        virtual const std::string typeName()
        {
            return PlotFunction_NODENAME;
        }

        void setAbscisse(Abscisse abscisse_)
        {
            abscisse = abscisse_;
        };

        Abscisse getAbscisse()
        {
            return abscisse;
        };

        Function getFunction()
        {
            return function;
        };

        void setFunction(Function function_)
        {
            function = function_;
        };

        void setParamsNbPoints(std::vector<std::string> paramsNbPoints_)

        {

            paramsNbPoints = paramsNbPoints_;

        };

        void setAbscisseScale(Axis::Scale scale)
        {
            abscisseScale = scale;
        };

        Axis::Scale getAbscisseScale()
        {
            return abscisseScale;
        };

        Axis::Scale getOrdonneeScale()
        {
            return ordonneeScale;
        };

        void setOrdonneeScale(Axis::Scale scale)
        {
            ordonneeScale = scale;
        };
        static QSASConfig *qsasconfig;

        void setTimeAxisDecorator(std::shared_ptr<TimeAxisDecorator> pDecorator_)
        {
            _xdecoratorPtr = pDecorator_;
        }

        std::shared_ptr<TimeAxisDecorator> getTimeAxisDecorator()
        {
            return _xdecoratorPtr;
        }

    protected:
        /**
         *@brief Draw the serie of a parameter component on plot.
         */
        virtual void
        drawSeries(double startDate, double stopDate, int intervalIndex, std::string pParamId,
                   SeriesProperties &pSerie,
                   AMDA::Common::ParameterIndexComponent pParamIndex,
                   ParameterAxes &param, bool moreThanOneSerieForAxis);

        virtual void preparePlotArea(double startTime, double stopTime, int intervalIndex);
        /**
         * @brief Get original id of the concerned parameter (for the plot) then add it to the usedParametersId_ and store it in originalParamId
         *
         * @param usedParametersId_
         */
        virtual void createParameters(std::list<std::string> &usedParametersId_);
        /**
         * @brief draw the plot for the current time interval
         */
        virtual bool draw(double startTime, double stopTime, int intervalIndex,
                          bool isFirstInterval, bool isLastInterval);

    private:
        void configureSeriesAxis();
        void configureAxisLegend();

        /**
         * @brief Afficher sur le plot the starting date
         *
         * @param _timeFormat le format
         * @param startTime le start time envoyé depuis le l'ihm
         * @param stopTime le stop time envoyé depuis le l'ihm
         */

        void drawStartDate(std::string _timeFormat, double startTime, double stopTime);

        /**
         * @brief Créer un axe Y pour accueillir les valeurs calculées de l'axe Y
         *
         */

        void createYAxis();

        /**
         * @brief Créer un axe X pour accueillir les valeurs calculées de l'axe X
         *
         */

        void createXAxis();

        /**
         * @brief Get the Min Max de xValuesMap et yValuesMap
         *
         * @param minToFill la variable qui store la valeur minimale
         * @param maxToFill la variable qui store la valeur maximale
         */

        void getMinMax(std::map<std::string, std::vector<double>>, double *minToFill, double *maxToFill);

        /**
         * @brief Appliquer le plotfunction soit FFT, SUM, ou AVG pour chaque pseudo-paramètre
         *
         * @param pParamIndex index of pseudo paramètre
         * @param ParameterData qui contient toute les données des paramètres
         * @param id id pseudo param
         * @param param_id id du paramètre
         */
        void compute(AMDA::Common::ParameterIndexComponent pParamIndex, plot::ParameterData data, std::string id, std::string param_id);

        /**
         * @brief Une map pour stocker les valeurs calculées de l'axe X associés aux pseudo paramètres crées localement
         *
         */

        std::map<std::string, std::vector<double>> xValuesMap;

        /**
         * @brief Une map pour stocker les valeurs calculées de l'axe Y associés aux pseudo paramètres crées localement
         *
         */

        std::map<std::string, std::vector<double>> yValuesMap;

        /**
         * @brief Type de function envoyée par l'IHM
         *  @see Function
         */

        Function function;

        /**
         * @brief Un vecteur qui associe l'id du vrai paramètre et le nb points choisi par l'ihm pour appliquer FFT
         *
         */

        std::vector<std::string> paramsNbPoints;

        /**
         * @brief Type d'abscisse en cas de FFT
         * @see Abscisse
         *
         */

        Abscisse abscisse;

        /**
         * @brief Scale of abscisse
         *
         */

        Axis::Scale abscisseScale;

        /**
         * @brief Scale for ordonnée
         *
         */

        Axis::Scale ordonneeScale;
        std::shared_ptr<TimeAxisDecorator> _xdecoratorPtr;

    };
}
#endif