#ifndef GTL_MATH_FFT_H
#define GTL_MATH_FFT_H

#include <QObject>
#include <cmath>
#include "fftw3.h"

#include "core/gtl_device.h"
#include "core/gtl_analog_data.h"
#include "core/gtl.h"
#include "gtl_math_filter_iir.h"
#include "math_global.h"

namespace gtl {
    namespace math {

        class MATH_EXPORT fft : public QObject, public std::vector<std::complex<double>>
        {
            Q_OBJECT

        public:
            enum windows
            {
                rectangular,
                cosine,
                hann,
                bartlett_hann,
                hamming,
                blackman,
                blackman_harris,
                flattop,
            };
            Q_ENUM(windows)

        public:
            fft(gtl::analog_data *ad);
            ~fft();

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

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

            gtl::analog_data *ad() const;

            int samples() const;     
            void init();

            int size_fft_out() const;
            int size_fft_calc() const;

        private:
            void decimate(std::vector<qreal>::iterator in_it, std::vector<qreal>::iterator out_it, int size, int N, int R);
            void cleanup();
            void adcopy(int adoffset);
            void calc();

            gtl::analog_data* _ad; // Без фильтра
            int _samples;

            qreal _f; // Верхняя частота
            qreal _rbw; // Разрешение
            windows _w; // Окно
            int _nl; // Кол-во линий
            int _av; // Количество усреднение
            int _ol; // Перекрытие
            units _un; // Единицы измерения

            std::vector<std::complex<double>>* _fft_out = nullptr;
            fftw_plan _plan = nullptr;
            bool _done;
            size_t _size_r; // Размер буфера после децимации
            size_t _size_r_k; // Размер буфера после децимации / 2 - до частоты Котельникова

            std::vector<std::vector<qreal>*> _buffer_out;
            int _size_out; // Количество отображаемых линий

            qreal _fs; // Частота дискритизации
            qreal _fk; // Частота Котельникова
            uint _cn; // Порядок гребенчатого фильтра
            uint _dr; // Коэффициент децимации

            size_t _size; // Размер буфера

            std::vector<qreal> *_buffer_w = nullptr; // Буфер оконной функции
            std::vector<qreal> *_buffer_in = nullptr; // Буфер входной
            int _buffer_ptr;
            int _buffer_ptr_offset;
            std::vector<qreal>* _fft_in = nullptr;
            gtl::device* _device;

        private slots:
            virtual void data_changed();
            virtual void set_rate(qreal value);

        signals:
            void frequency_changed();
            void resolution_changed();
            void window_changed();
            void lines_changed();
            void overlap_changed();

            void initialized();
            void changed();
            void deleting();

        };

    } // namespace math
} // namespace gtl

#endif // GTL_MATH_FFT_H