#ifndef GTL_MATH_APFC_H
#define GTL_MATH_APFC_H

#include <QObject>
#include <algorithm>

#include "core/gtl_device.h"
#include "core/gtl_analog_data.h"
#include "gtl_math_fft.h"
#include "math_global.h"

namespace gtl {
    namespace math {

        class MATH_EXPORT apfc : public QObject, public std::vector<std::pair<qreal,qreal>>
        {
            Q_OBJECT

            Q_PROPERTY(qreal frequency READ frequency WRITE set_frequency NOTIFY frequency_changed);
            Q_PROPERTY(qreal resolution READ resolution WRITE set_resolution NOTIFY resolution_changed);
            Q_PROPERTY(windows window READ window WRITE set_window NOTIFY window_changed);
            Q_PROPERTY(int lines READ lines WRITE set_lines NOTIFY lines_changed);
            Q_PROPERTY(int average READ average WRITE set_average NOTIFY average_changed);
            Q_PROPERTY(int overlap READ overlap WRITE set_overlap NOTIFY overlap_changed);
            Q_PROPERTY(qreal acq_time READ acq_time NOTIFY acq_time_changed);
            Q_PROPERTY(afcs afc READ afc WRITE set_afc NOTIFY afc_changed);
            Q_PROPERTY(pfcs pfc READ pfc WRITE set_pfc NOTIFY pfc_changed);
            Q_PROPERTY(qreal threshold READ threshold WRITE set_threshold NOTIFY threshold_changed)

        public:

            typedef fft::windows windows;
//            Q_ENUM(windows)

            enum afcs
            {
                magnitude,
                db,
                coherence
            };
            Q_ENUM(afcs)

            enum pfcs
            {
                deg,
                rad
            };
            Q_ENUM(pfcs)

            apfc(gtl::analog_data *ref, gtl::analog_data *data);
            ~apfc();

            void set_ref(gtl::analog_data *ref);
            void set_data(gtl::analog_data *data);

            qreal frequency() const;
            void set_frequency(qreal value);

            qreal resolution() const;
            void set_resolution(qreal value);

            windows window() const;
            void set_window(windows value);

            int lines() const;
            void set_lines(int value);

            uint average() const;
            void set_average(int value);

            qreal overlap() const;
            void set_overlap(int value);

            gtl::analog_data *ad() const;

            qreal acq_time() const;

            afcs afc() const;
            void set_afc(afcs value);

            pfcs pfc() const;
            void set_pfc(pfcs value);

            qreal threshold() const;
            void set_threshold(qreal newThreshold);

        private:
            void cleanup();

            bool _is_acq;
            int _av; // Количество усреднений
            afcs _afc; // Единицы измерения АЧХ
            pfcs _pfc; // Единицы измерения ФЧХ
            int _av_cnt; // Счетчик усреднений
            bool _av_filled; // Флаг заполнения окна усреднения
            qreal _ac; // Процент завершения усреднения
            qreal _threshold; // Порог % от max

//            gtl::analog_data* _ad;

            std::vector<std::vector<std::pair<qreal,qreal>>*> _buffer_out;
            std::vector<std::pair<qreal,qreal>>::iterator _calculated_it; // Итератор текущего буффера для вычисления спектра

            int _size_fft_calc; // Размер буфера/ 2 - до частоты Котельникова
            int _size_fft_out; // Количество отображаемых линий

            math::fft* _ref; // БПФ эталона
            math::fft* _data; // БПФ данных

            gtl::device* _device;

        protected:
            virtual void calculate();
            virtual void before_updating();
            virtual void after_updating();

        private slots:
            virtual void device_recieved_data();
            void init();

        public slots:
            void stop_acq();

        signals:
            void frequency_changed();
            void resolution_changed();
            void window_changed();
            void lines_changed();
            void average_changed();
            void overlap_changed();
            void acq_time_changed();
            void afc_changed();
            void pfc_changed();
            void threshold_changed();

            void initialized();
            void changed();
            void acquired(qreal);
            void deleting();
        };

    } // namespace math
} // namespace gtl

#endif // GTL_MATH_APFC_H