#ifndef GTL_MATH_DELTA_PHASE_H
#define GTL_MATH_DELTA_PHASE_H

#include <QObject>
#include <QDateTime>

#include "gtl_math_analog_value.h"
#include "math_global.h"
#include "core/gtl_analog_data.h"
#include "gtl_math_freq.h"

namespace gtl {
    namespace math {


        class  last_front : public analog_value
        {
            Q_OBJECT
        public:
            last_front(gtl::analog_data *data)
            : analog_value(data)
            , _front(-1)
            , _freq(100)
            {

            }

            int front(){return _front;}
            void set_freq(qreal value)
            {
                if(value != _freq && value > 0)
                {
                    _freq = value;
                    analog_value::set_time(1.1/_freq);
                    _front = -1;
                }
            }
            qreal freq(){return _freq;}

            virtual void set_time(qreal value) override{ analog_value::set_time(value); }

        private:
            virtual void before_copying_data(std::vector<qreal>::iterator begin, std::vector<qreal>::iterator end) override{}
            virtual void after_copying_data(std::vector<qreal>::iterator begin, std::vector<qreal>::iterator end) override{}

        protected slots:
            virtual void data_changed() override
            {
                _ad->lock_device();
                if(_ad->size() >= _data.size())
                {
                    std::copy(_ad->end() - _data.size(), _ad->end(), _data.begin());
                }
                else
                {
                    int dif = _data.size() - _ad->size();
                    std::copy(_data.end() - dif, _data.end(), _data.begin());
                    std::copy(_ad->begin(), _ad->end(), _data.begin() + dif);
                }
                _ad->unlock_device();

                qreal dc = 0;//std::accumulate(_data.begin(), _data.end(), 0.0)/_data.size();
                for(int i = _data.size() - 1; i > 0; --i)
                {
                    if(_data[i] >= dc && _data[i-1] < dc)
                    {
                        _front = _data.size() - i;
                        break;
                    }
                }
            }
        private:
            int _front;
            qreal _freq;

        };

        class MATH_EXPORT delta_phase : public last_front
        {
            Q_OBJECT
        public:
            delta_phase(gtl::analog_data *ref, gtl::analog_data *data);
            ~delta_phase();

            virtual void set_time(qreal value) override;

        private:
            last_front* _ref = NULL;
            last_front* _data = NULL;
            gtl::math::freq *_freq = NULL;

        private:
            virtual void before_copying_data(std::vector<qreal>::iterator begin, std::vector<qreal>::iterator end) override;
            virtual void after_copying_data(std::vector<qreal>::iterator begin, std::vector<qreal>::iterator end) override;

        protected slots:
            virtual void data_changed() override;

        };
    } // namespace math
} // namespace gtl

#endif // GTL_MATH_DELTA_PHASE_H