#ifndef MATH_SPEC_H
#define MATH_SPEC_H

#include <QObject>
#include <cmath>
#include <QDebug>
#include <QThread>
#include <tuple>
#include "fftw3.h"

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

namespace gtl
{
    namespace math
    {
        class MATH_EXPORT spec : public QObject, public std::vector<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(units unit READ unit WRITE set_unit NOTIFY unit_changed);
            Q_PROPERTY(qreal acq_time READ acq_time NOTIFY acq_time_changed);

        public:

            typedef fft::windows windows;

            enum types
            {
                ausp,
                spen,
                phase,

                undef = 0xff
            };
            Q_ENUM(types)

            spec(types type, gtl::analog_data *ad);
            ~spec();

            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);

            units unit() const;
            units get_unit() const;
            void set_unit(units value);

            gtl::analog_data *ad() const;

            types type() const;
            void set_type(types type);

            qreal acq_time() const;
            int samples() const;

//            void set_measures(SpecMeasParamsListPtr m);
        private:
            void cleanup();
            void calculate_ampl(std::vector<std::complex<double>> *in_it, std::vector<qreal>::iterator out_it, int size);
            void calculate_phase(std::vector<std::complex<double>> *in_it, std::vector<qreal>::iterator out_it, int size);
//            void measure();

            gtl::math::fft* _fft;

            bool _is_acq;

            int _av; // Количество усреднение
            units _un; // Единицы измерения
            int _av_cnt; // Счетсик усреднений
            bool _av_filled; // Флаг заполнения окна усреднения
            qreal _ac; // Процент завершения усреднения

            gtl::analog_data* _ad;

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

            fftw_plan _ispen_plan = NULL; // оБПФ план комплексной огибающей
            fftw_plan _spen_plan = NULL; // БПФ план комплексной огибающей
            std::vector<std::complex<double>>* _ispen_fft = NULL; // Сигнал комплексной огибающей
            std::vector<std::complex<double>>* _spen_fft = NULL; // Спектр комплексной огибающей

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

//            unsigned long _ttt = 0;

        protected:
            std::vector<qreal>* _envelope = NULL; // Комплексная огибающая
            types _type;

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

        private slots:
            virtual void data_changed();
            virtual void set_rate(qreal value);
            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 unit_changed();
            void acq_time_changed();
//            void measures_changed();

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

        };
    }
}

#endif // MATH_SPEC_H