/* 
 * File:   CountStatistic.hh
 * Author: AKKA
 *
 * Created on December 20, 2019, 1:44 PM
 */

#ifndef COUNTSTATISTIC_HH
#define COUNTSTATISTIC_HH

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

namespace AMDA {
    namespace Statistic {
        namespace CountBool {

            using namespace AMDA::Parameters;

            typedef enum {
                FT_COUNT_TRUE,
            } COUNT_BOOL_FUNC_TYPE;

            template <typename TParamData, typename TResultData>
            class CountStatisticOperation : public StatisticOperation<TResultData> {
            public:
                typedef typename TParamData::ElementType ElementType;

                CountStatisticOperation(StatisticProcess& process,
                        TimeIntervalListSPtr pTimeIntervalList, TParamData &param, COUNT_BOOL_FUNC_TYPE funcType) :
                StatisticOperation<TResultData>(process),
                _paramInput(param), _timeIntervalList(pTimeIntervalList),
                _currentTimeInterval(_timeIntervalList->begin()),
                _funcType(funcType), _dimDef("unknown") {
                    resetData(StatisticOperation<TResultData>::_resultData);
                }

                virtual ~CountStatisticOperation(void) {
                }

                virtual void compute(ParamDataIndexInfo &pParamDataIndexInfo) {
                    for (unsigned int index = pParamDataIndexInfo._startIndex;
                            index < pParamDataIndexInfo._startIndex
                            + pParamDataIndexInfo._nbDataToProcess;
                            index++) {
                        _val = _paramInput.get(index);
                        switch (_funcType) {
                            case FT_COUNT_TRUE:
                                countTrue(_val);
                                break;
                        }
                    }
                }

                virtual void finalizeCompute(void) {
                    // do nothing averything is ok
                }

                virtual std::string getResultDimDefinition(bool /* forCoverage */) {
                    return _dimDef.str();
                }

                virtual void reset() {
                    StatisticOperation<TResultData>::reset();
                    resetData(StatisticOperation<TResultData>::_resultData);
                }
            private:

                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 countTrue(Type &a) {
                    _dimDef.str("1");
                    if (typeid (a) != typeid ( AMDA::Parameters::LogicalData)) {
                        BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL) << AMDA::ex_msg("Only boolean params are supported supported"));
                        return;
                    }
                    if (isNAN(StatisticOperation<TResultData>::_resultData._result))
                        StatisticOperation<TResultData>::_resultData._result = 0;
                    ++StatisticOperation<TResultData>::_resultData._nbDataProcessed;
                    if (isNAN(a) || a != AMDA::Parameters::LogicalData::True)
                        return;
                    ++StatisticOperation<TResultData>::_resultData._result;
                }

                template<typename Type>
                void countTrue(std::vector<Type> &a) {
                    if (StatisticOperation<TResultData>::_resultData.empty()) {
                        _dimDef.str("");
                        _dimDef << a.size();
                        for (unsigned int i = 0; i < a.size(); ++i) {
                            if (typeid (a[i]) != typeid ( AMDA::Parameters::LogicalData)) {
                                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL) << AMDA::ex_msg("Only boolean params are supported supported"));
                                return;
                            }
                            StatisticDataScalar<int> data;
                            resetData(data);
                            ++data._nbDataProcessed;
                            data._result = 0;
                            if (!isNAN(a[i]) && (int) a[i] == AMDA::Parameters::LogicalData::True)
                                ++ data._result;
                            StatisticOperation<TResultData>::_resultData.push_back(data);
                        }
                        return;
                    }
                    for (unsigned int i = 0; i < StatisticOperation<TResultData>::_resultData.size(); ++i) {
                        if (isNAN(a[i]))
                            continue;
                        ++StatisticOperation<TResultData>::_resultData[i]._nbDataProcessed;
                        if (a[i] == AMDA::Parameters::LogicalData::True)
                            ++StatisticOperation<TResultData>::_resultData[i]._result;
                    }
                }

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

                TimeIntervalListSPtr _timeIntervalList;

                TimeIntervalList::iterator _currentTimeInterval;

                ElementType _val;

                COUNT_BOOL_FUNC_TYPE _funcType;

                std::stringstream _dimDef;

            }; //Class Count

            class CreateCountBoolStatistic : public VisitorOfParamData {
            public:

                CreateCountBoolStatistic(StatisticProcess& pProcess,
                        TimeIntervalListSPtr pTimeIntervalList,
                        ParamData &paramData, COUNT_BOOL_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 *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataScalaireFloat *)
                 */
                virtual void visit(ParamDataScalaireFloat *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataScalaireDouble *)
                 */
                virtual void visit(ParamDataScalaireDouble *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataScalaireLongDouble *)
                 */
                virtual void visit(ParamDataScalaireLongDouble *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataScalaireInt *)
                 */
                virtual void visit(ParamDataScalaireInt *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

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

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab1DShort *)
                 */
                virtual void visit(ParamDataTab1DShort *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab1DFloat *)
                 */
                virtual void visit(ParamDataTab1DFloat *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab1DDouble *)
                 */
                virtual void visit(ParamDataTab1DDouble *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab1DLongDouble *)
                 */
                virtual void visit(ParamDataTab1DLongDouble *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab1DInt *)
                 */
                virtual void visit(ParamDataTab1DInt *) {
                    BOOST_THROW_EXCEPTION(
                            AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL)
                            << AMDA::ex_msg(
                            "Only boolean parameters are supported"));
                }

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

                /**
                 * @overload VisitorOfParamData::visit(ParamDataTab2DShort *)
                 */
                virtual void visit(ParamDataTab2DShort *) {
                    BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_STAT_NOT_BOOL) << 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_STAT_NOT_BOOL) << 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_STAT_NOT_BOOL) << 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_STAT_NOT_BOOL) << 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_STAT_NOT_BOOL) << 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_STAT_NOT_BOOL) << AMDA::ex_msg("ParamDataTab2DLogicalData data not supported"));
                }

            private:
                StatisticProcess& _process;

                TimeIntervalListSPtr& _timeIntervalList;

                ParamData &_paramData;

                StatisticOperationBase *_operation;

                COUNT_BOOL_FUNC_TYPE _type;


            };

        }//Count
    }//STATISTIC
} //AMDA



#endif /* COUNTSTATISTIC_HH */