/**
 * MinMaxMeanStatistic.hh
 *
 *  Created on: 04 nov. 2014
 *      Author: AKKA
 */

#ifndef MINMAXMEANSTATISTIC_HH_
#define MINMAXMEANSTATISTIC_HH_

#include "ParamData.hh"
#include "DataTypeMath.hh"
#include "VisitorOfParamData.hh"
#include "StatisticData.hh"
#include "StatisticOperation.hh"
#include "StatisticProcess.hh"
#include <math.h>
#include <type_traits>

#include "TimeInterval.hh"

namespace AMDA {
    namespace Statistic {
        namespace MinMaxMean {

            using namespace AMDA::Parameters;

            typedef enum {
                FT_MIN,
                FT_MAX,
                FT_MEAN,
                FT_RMS,
                FT_MEDIAN,
                FT_VARIANCE,
                FT_SKEWNESS,
                FT_KURTOSIS,
                FT_FIRST_VALUE,
                FT_MIDDLE_VALUE,
                FT_LAST_VALUE
            } FUNC_TYPE;

            template<typename TParamData, typename TResultData>
            class MinMaxMeanStatisticOperation : public StatisticOperation<TResultData> {
            public:
                /**
                 * @brief  Element type of paramData
                 */
                typedef typename TParamData::ElementType ElementType;


                using TimeDataList = std::vector<std::pair<double, ElementType>>;

                MinMaxMeanStatisticOperation(StatisticProcess& process,
                        TimeIntervalListSPtr pTimeIntervalList, TParamData &param, FUNC_TYPE funcType) :
                StatisticOperation<TResultData>(process),
                _paramInput(param), _timeIntervalList(pTimeIntervalList),
                _currentTimeInterval(_timeIntervalList->begin()),
                _funcType(funcType), _dimDef("unknown") {
                    ElementType fillValue;
                    fillValue << NotANumber();
                    initDimSize(fillValue);
                    resetData(StatisticOperation<TResultData>::_resultData);
                }

                virtual ~MinMaxMeanStatisticOperation(void) {
                }

                virtual void compute(ParamDataIndexInfo &pParamDataIndexInfo) {
                    for (unsigned int index = pParamDataIndexInfo._startIndex;
                            index < pParamDataIndexInfo._startIndex
                            + pParamDataIndexInfo._nbDataToProcess;
                            index++) {
                        _val = _paramInput.get(index);
                        double crtTime = _paramInput.getTime(index);
                        switch (_funcType) {
                            case FT_MIN:
                                computeMin(_val);
                                break;
                            case FT_MAX:
                                computeMax(_val);
                                break;
                            case FT_MEAN:
                                addForMean(_val);
                                break;
                            case FT_RMS:
                                addForRMS(_val);
                                break;
                            case FT_MEDIAN:
                                addForMean(_val);
                                generateVector(_val);
                                break;
                            case FT_VARIANCE:
                                addForMean(_val);
                                generateVector(_val);
                                break;
                            case FT_SKEWNESS:
                                addForMean(_val);
                                generateVector(_val);
                                break;
                            case FT_KURTOSIS:
                                addForMean(_val);
                                generateVector(_val);
                                break;
                            case FT_MIDDLE_VALUE:
                                addForMean(_val);
                                generateTimeDataVector(crtTime, _val);
                            case FT_FIRST_VALUE:
                            case FT_LAST_VALUE:
                                addForMean(_val);
                                generateVector(_val);
                                break;

                        }
                    }
                }

                virtual void finalizeCompute(void) {
                    if (_funcType == FT_MEAN)
                        finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
                    if (_funcType == FT_RMS)
                        finalizeRMSResult(StatisticOperation<TResultData>::_resultData);
                    if (_funcType == FT_MEDIAN)
                        finalizeMedianResult(StatisticOperation<TResultData>::_resultData);
                    if (_funcType == FT_VARIANCE) {
                        finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
                        finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                    } else if (_funcType == FT_SKEWNESS) {
                        finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
                        finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                        finalizeSkewnessResult(StatisticOperation<TResultData>::_resultData);
                    } else if (_funcType == FT_KURTOSIS) {
                        finalizeMeanResult(StatisticOperation<TResultData>::_resultData);
                        finalizeVarianceResult(StatisticOperation<TResultData>::_resultData);
                        finalizeKurtosisResult(StatisticOperation<TResultData>::_resultData);
                    } else if (_funcType == FT_FIRST_VALUE) {
                        finalizeFirstValueResult(StatisticOperation<TResultData>::_resultData);
                    }else if (_funcType == FT_MIDDLE_VALUE) {
                        finalizeMiddleValueResult(StatisticOperation<TResultData>::_resultData);
                    } else if (_funcType == FT_LAST_VALUE) {
                        finalizeLastValueResult(StatisticOperation<TResultData>::_resultData);
                    }
                }

                virtual void reset() {
                    StatisticOperation<TResultData>::reset();
                    resetData(StatisticOperation<TResultData>::_resultData);
                    _dataList.clear();
                    _timeDataList.clear();
                    ++_currentTimeInterval;
                }

                /**
                 * @brief Get the result dimensiond efinition.
                 */
                virtual std::string getResultDimDefinition(bool /* forCoverage */) {
                    return _dimDef.str();
                }

            private:
                template<typename Type>
                void initDimSize(Type &/*a*/) {
                    _dimDef.str("1");
                }

                template<typename Type>
                void initDimSize(std::vector<Type> &/*a*/) {
                    _dimDef.str("unknown");
                }


                template<typename Type>
                void resetData(Type &a) {
                    a._result << NotANumber();
                    a._nbDataProcessed = 0;
                }

                template<typename Type>
                void resetData(std::vector<Type> &a) {
                    a.clear();
                }

                template<typename Type>
                void computeMin(Type &a) {
                    if (isNAN(a))
                        return;

                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a;
                    else if (a < StatisticOperation<TResultData>::_resultData._result)
                        StatisticOperation<TResultData>::_resultData._result = a;
                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
                }

                template<typename Type>
                void computeMin(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();
                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                        return;
                    }

                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
                        if (isNAN(a[i]))
                            continue;

                        if (isNAN(StatisticOperation<TResultData>::_resultData[i]._result))
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i];
                        else if (a[i] < StatisticOperation<TResultData>::_resultData[i]._result)
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i];
                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
                    }
                }

                template<typename Type>
                void computeMax(Type &a) {
                    if (isNAN(a))
                        return;

                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a;
                    else if (a > StatisticOperation<TResultData>::_resultData._result)
                        StatisticOperation<TResultData>::_resultData._result = a;
                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
                }

                template<typename Type>
                void computeMax(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();

                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                        return;
                    }

                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
                        if (isNAN(a[i]))
                            continue;

                        if (isNAN(StatisticOperation<TResultData>::_resultData[i]._result))
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i];
                        else if (a[i] > StatisticOperation<TResultData>::_resultData[i]._result)
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i];
                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
                    }
                }

                template<typename Type>
                void addForMean(Type &a) {
                    if (isNAN(a))
                        return;

                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a;
                    else
                        StatisticOperation<TResultData>::_resultData._result = StatisticOperation<TResultData>::_resultData._result + a;
                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
                }

                template<typename Type>
                void addForMean(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();

                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                        return;
                    }

                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
                        if (isNAN(a[i]))
                            continue;

                        if (isNAN(StatisticOperation<TResultData>::_resultData[i]._result))
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i];
                        else
                            StatisticOperation<TResultData>::_resultData[i]._result = StatisticOperation<TResultData>::_resultData[i]._result + a[i];
                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
                    }
                }

                template<typename Type>
                void addForRMS(Type &a) {
                    if (isNAN(a))
                        return;

                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a * a;
                    else
                        StatisticOperation<TResultData>::_resultData._result = StatisticOperation<TResultData>::_resultData._result + a*a;
                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
                }

                template<typename Type>
                void addForRMS(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();

                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i] * a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                        return;
                    }

                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
                        if (isNAN(a[i]))
                            continue;

                        if (isNAN(StatisticOperation<TResultData>::_resultData[i]._result))
                            StatisticOperation<TResultData>::_resultData[i]._result = a[i] * a[i];
                        else
                            StatisticOperation<TResultData>::_resultData[i]._result = StatisticOperation<TResultData>::_resultData[i]._result + a[i] * a[i];
                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
                    }
                }

                template<typename Type>
                void generateVector(Type &a) {
                    if (isNAN(a))
                        return;
                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a;
                    _dataList.push_back(a);
                }

                template<typename Type>
                void generateVector(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();

                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                    }

                    if (_dataList.empty()) {
                        // init _dataList  
                        for (int i = 0; i < a.size(); i++) {
                            std::vector<Type> vec;
                            if (!isNAN(a))
                                vec.push_back(a[i]);
                            _dataList.push_back(vec);
                            vec.clear();
                        }
                    } else {
                        //remplir dataList
                        for (int i = 0; i < a.size(); i++) {
                            if (!isNAN(a[i]))
                                _dataList[i].push_back(a[i]);
                        }
                    }

                }

                template<typename Type>
                void generateTimeDataVector(double time, Type &a) {
                    _dimDef.str("1");
                    if (isNAN(a))
                        return;
                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = a;
                    _timeDataList.push_back(std::make_pair(time, a));
                }

                template<typename Type>
                void generateTimeDataVector(double time, std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();

                        for (unsigned int i = 0; i < a.size(); ++i) {
                            StatisticDataScalar<Type> data;
                            resetData(data);
                            data._result = a[i];
                            if (!isNAN(a))
                                ++data._nbDataProcessed;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                    }
                    // fill timeDataList
                    std::vector<Type> vec;
                    for (int i = 0; i < a.size(); i++) 
                         vec.push_back(a[i]);
                     _timeDataList.push_back(std::make_pair(time, vec));
                     vec.clear();
                }

                template<typename Type>
                void finalizeMeanResult(Type& a) {
                    if (!isNAN(a._result) && a._nbDataProcessed > 0)
                        a._result /= a._nbDataProcessed;
                    _mean = a._result;

                }

                template<typename Type>
                void finalizeMeanResult(std::vector<Type>& a) {
                    for (unsigned int i = 0; i < a.size(); ++i) {
                        if (!isNAN(a[i]._result) && a[i]._nbDataProcessed > 0) {
                            a[i]._result /= a[i]._nbDataProcessed;
                            _mean.push_back(a[i]._result);
                        }
                    }
                }

                template<typename Type>
                void finalizeRMSResult(Type& a) {
                    if (!isNAN(a._result) && a._nbDataProcessed > 0)
                        a._result = sqrt(a._result / a._nbDataProcessed);
                }

                template<typename Type>
                void finalizeRMSResult(std::vector<Type>& a) {
                    for (int i = 0; i < a.size(); i++) {
                        if (!isNAN(a[i]._result) && a[i]._nbDataProcessed > 0)
                            a[i]._result = sqrt(a[i]._result / a[i]._nbDataProcessed);
                    }
                }

                template<typename Type>
                void finalizeMedianResult(Type & a) {
                    std::size_t size = _dataList.size();
                    if (size == 0)
                        return;
                    std::sort(_dataList.begin(), _dataList.end());
                    if (size % 2 == 0) {
                        a._result = (_dataList[size / 2 - 1] + _dataList[size / 2]) / 2;
                    } else {
                        a._result = _dataList[floor(size / 2)];
                    }
                }

                template<typename Type>
                void finalizeMedianResult(std::vector<Type>& a) {
                    for (int i = 0; i < a.size(); i++) {
                        std::size_t size = _dataList[i].size();
                        if (size == 0)
                            return;
                        std::sort(_dataList[i].begin(), _dataList[i].end());
                        if (size % 2 == 0) {
                            a[i]._result = (_dataList[i][size / 2 - 1] + _dataList[i][size / 2]) / 2;
                        } else {
                            a[i]._result = _dataList[i][floor(size / 2)];
                        }
                    }
                }

                template<typename Type>
                void finalizeFirstValueResult(Type & a) {
                    if (_dataList.size() == 0)
                        return;
                    a._result = _dataList[0];
                }

                template<typename Type>
                void finalizeFirstValueResult(std::vector<Type>& a) {
                    for (int i = 0; i < a.size(); i++) {
                        if (_dataList[i].size() == 0)
                            return;
                        a[i]._result = _dataList[i][0];
                    }
                }

                template<typename Type>
                void finalizeLastValueResult(Type & a) {
                    if (_dataList.size() == 0)
                        return;
                    a._result = _dataList.back();
                }

                template<typename Type>
                void finalizeLastValueResult(std::vector<Type>& a) {
                    for (int i = 0; i < a.size(); i++) {
                        if (_dataList[i].size() == 0)
                            return;
                        a[i]._result = _dataList[i].back();
                    }
                }

                template<typename Type>
                void finalizeMiddleValueResult(Type & a) {
                    if (_timeDataList.size() == 0)
                        return;
                    if (_timeDataList.size() == 1) {
                        a._result = _timeDataList[0].second;
                        return;
                    } else {
                        double middeTime = (_currentTimeInterval->_startTime + _currentTimeInterval->_stopTime) / 2;
                        for (int i = 0; i < _timeDataList.size(); i++) {
                            if (_timeDataList[i].first == middeTime) {
                                a._result = _timeDataList[i].second;
                                return;
                            } else if (_timeDataList[i].first > middeTime) {
                                a._result = _timeDataList[i - 1].second + (_timeDataList[i].second - _timeDataList[i - 1].second)*
                                        ((middeTime - _timeDataList[i - 1].first) / (_timeDataList[i].first - _timeDataList[i - 1].first));
                                return;
                            }
                        }
                    }
                }

                template<typename Type>
                void finalizeMiddleValueResult(std::vector<Type> & a) {

                    //vector of pair <time dataScalar>
                    std::vector<std::pair<double, double>> timeDataList;
                    for (int i = 0; i < a.size(); i++) {
                        for (auto val : _timeDataList) {
                            if (!isNAN(val.second[i]))
                                timeDataList.push_back(std::make_pair(val.first, (double) val.second[i]));
                        }
                    
                    if (timeDataList.size() == 0)
                        continue;
                    a[i]._result = getMiddleValue(timeDataList);
                    timeDataList.clear();
                }
                }
            

            double getMiddleValue(std::vector<std::pair<double, double >> time1DDataList) {
                if (time1DDataList.size() == 1) {
                    return time1DDataList[0].second;
                }
                double middeTime = (_currentTimeInterval->_startTime + _currentTimeInterval->_stopTime) / 2;
                double res = std::numeric_limits<double>::quiet_NaN();
                for (int i = 0; i < time1DDataList.size(); i++) {
                    if (time1DDataList[i].first == middeTime) {
                        res= time1DDataList[i].second;
                        break;
                    } else if (time1DDataList[i].first > middeTime) {
                        res = time1DDataList[i - 1].second + (time1DDataList[i].second - time1DDataList[i - 1].second)*
                                ((middeTime - time1DDataList[i - 1].first) / (time1DDataList[i].first - time1DDataList[i - 1].first));
                        break;
                    }
                }
                return res;
            }

            template<typename Type>
            void finalizeVarianceResult(Type & a) {
                if (_dataList.size() == 0)
                    return;
                double accum = 0.0;
                std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
                    accum += (d - _mean) * (d - _mean);
                });
                a._result = accum / (_dataList.size());
                _standardDeviation = sqrt(a._result);
            }

            template<typename Type>
            void finalizeVarianceResult(std::vector<Type> & a) {
                for (int i = 0; i < a.size(); i++) {
                    if (_dataList[i].size() == 0)
                        return;
                    double accum = 0.0;
                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
                        accum += (d - _mean[i]) * (d - _mean[i]);
                    });
                    a[i]._result = accum / (_dataList[i].size());
                    _standardDeviation.push_back(sqrt(a[i]._result));
                }
            }

            template<typename Type>
            void finalizeSkewnessResult(Type & a) {
                int n = _dataList.size();
                if (n == 0)
                    return;
                double accum = 0.0;
                std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
                    accum += (d - _mean) * (d - _mean) * (d - _mean);
                });
                a._result = n / ((double) (n - 1)*(n - 2)) * accum / pow(_standardDeviation, 3);
            }

            template<typename Type>
            void finalizeSkewnessResult(std::vector<Type> & a) {
                for (int i = 0; i < a.size(); i++) {
                    int n = _dataList[i].size();
                    if (n == 0)
                        return;
                    double accum = 0.0;
                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]);
                    });
                    a[i]._result = n / ((double) (n - 1)*(n - 2)) * accum / pow(_standardDeviation[i], 3);
                }
            }

            template<typename Type>
            void finalizeKurtosisResult(Type & a) {
                int n = _dataList.size();
                if (n == 0)
                    return;
                double accum = 0.0;
                std::for_each(std::begin(_dataList), std::end(_dataList), [&](const double d) {
                    accum += (d - _mean) * (d - _mean) * (d - _mean) * (d - _mean) / pow(_standardDeviation, 4);
                });
                a._result = n * (n + 1) / ((double) (n - 1)*(n - 2)*(n - 3)) * accum - 3 * (n - 1)*(n - 1) / ((double) (n - 2)*(n - 3));
            }

            template<typename Type>
            void finalizeKurtosisResult(std::vector<Type> & a) {
                for (int i = 0; i < a.size(); i++) {
                    int n = _dataList[i].size();
                    if (n == 0)
                        return;
                    double accum = 0.0;
                    std::for_each(std::begin(_dataList[i]), std::end(_dataList[i]), [&](const double d) {
                        accum += (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) * (d - _mean[i]) / pow(_standardDeviation[i], 4);
                    });
                    a[i]._result = n * (n + 1) / ((double) (n - 1)*(n - 2)*(n - 3)) * accum - 3 * (n - 1)*(n - 1) / ((double) (n - 2)*(n - 3));
                }
            }

            /**
             * @brief real ParamData Input
             */
            TParamData& _paramInput;

            TimeIntervalListSPtr _timeIntervalList;

            TimeIntervalList::iterator _currentTimeInterval;

            ElementType _val;

            ElementType _mean;

            ElementType _standardDeviation;

            std::vector<ElementType> _dataList;

            /*
             * vector of pair<time, data> 
             */
            TimeDataList _timeDataList;


            FUNC_TYPE _funcType;

            std::stringstream _dimDef;
        };

        class CreateMinMaxMeanStatistic : public VisitorOfParamData {
        public:

            /**
             * @brief constructor
             */
            CreateMinMaxMeanStatistic(StatisticProcess& pProcess,
                    TimeIntervalListSPtr pTimeIntervalList,
                    ParamData &paramData, FUNC_TYPE type) :
            _process(pProcess), _timeIntervalList(pTimeIntervalList),
            _paramData(paramData), _operation(NULL), _type(type) {
                _paramData.accept(*this);
            }

            StatisticOperationBase* getStatisticOperation(void) {
                return _operation;
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataScalaireShort *)
             */
            virtual void visit(ParamDataScalaireShort *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireShort, StatisticDataScalar<short>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataScalaireShort &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
             */
            virtual void visit(ParamDataScalaireFloat *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireFloat, StatisticDataScalar<float>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataScalaireFloat &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
             */
            virtual void visit(ParamDataScalaireDouble *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireDouble, StatisticDataScalar<double>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataScalaireDouble &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
             */
            virtual void visit(ParamDataScalaireLongDouble *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireLongDouble, StatisticDataScalar<long double>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataScalaireLongDouble &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
             */
            virtual void visit(ParamDataScalaireInt *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataScalaireInt, StatisticDataScalar<int>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataScalaireInt &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataLogicalData *)
             */
            virtual void visit(ParamDataLogicalData *) {
                BOOST_THROW_EXCEPTION(
                        AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN)
                        << AMDA::ex_msg(
                        "CreateStatistic operation not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DShort *)
             */
            virtual void visit(ParamDataTab1DShort *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DShort, StatisticDataVector<short>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataTab1DShort &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
             */
            virtual void visit(ParamDataTab1DFloat *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DFloat, StatisticDataVector<float>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataTab1DFloat &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
             */
            virtual void visit(ParamDataTab1DDouble *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DDouble, StatisticDataVector<double>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataTab1DDouble &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
             */
            virtual void visit(ParamDataTab1DLongDouble *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DLongDouble, StatisticDataVector<long double>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataTab1DLongDouble &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
             */
            virtual void visit(ParamDataTab1DInt *) {
                _operation = new MinMaxMeanStatisticOperation<ParamDataTab1DInt, StatisticDataVector<int>>(_process,
                        _timeIntervalList, dynamic_cast<ParamDataTab1DInt &> (_paramData), _type);
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab1DLogicalData *)
             */
            virtual void visit(ParamDataTab1DLogicalData *) {
                BOOST_THROW_EXCEPTION(
                        AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN)
                        << AMDA::ex_msg(
                        "CreateStatistic operation not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
             */
            virtual void visit(ParamDataTab2DShort *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DShort data not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DFloat *)
             */
            virtual void visit(ParamDataTab2DFloat *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DFloat data not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DDouble *)
             */
            virtual void visit(ParamDataTab2DDouble *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DDouble data not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DLongDouble *)
             */
            virtual void visit(ParamDataTab2DLongDouble *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DLongDouble data not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DInt *)
             */
            virtual void visit(ParamDataTab2DInt *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DInt data not supported"));
            }

            /**
             * @overload VisitorOfParamData::visit(ParamDataTab2DLogicalData *)
             */
            virtual void visit(ParamDataTab2DLogicalData *) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_ERROR_UNKNOWN) << AMDA::ex_msg("ParamDataTab2DLogicalData data not supported"));
            }

        private:
            StatisticProcess& _process;

            TimeIntervalListSPtr& _timeIntervalList;

            ParamData &_paramData;

            StatisticOperationBase *_operation;

            FUNC_TYPE _type;
        };

    } /* namespace MinMaxMean */
} /* namespace Statistic */
} /* namespace AMDA */

#endif /* MINMAXMEANSTATISTIC_HH_ */