#ifndef SCR_SPEC_H
#define SCR_SPEC_H

#include <QVariant>
#include <QJSValue>
#include <QJsonObject>
#include <QJsonArray>

#include "math/gtl_math_spec.h"

#include "gtl_scr_spec_harms.h"
#include "gtl_scr_spec_humps.h"

#include "script_global.h"

namespace gtl
{
    namespace scr
    {
        class SCRIPT_EXPORT spec : public gtl::math::spec
        {
            Q_OBJECT

            Q_PROPERTY(QString name READ name WRITE set_name NOTIFY name_changed)
            Q_PROPERTY(int color READ color WRITE set_color NOTIFY color_changed)
            Q_PROPERTY(bool visible READ is_visible WRITE set_visible NOTIFY visible_changed)
            Q_PROPERTY(int smoothing_factor READ smoothing_factor WRITE set_smoothing_factor NOTIFY smoothing_factor_changed)
            Q_PROPERTY(int smoothed_line_color READ smoothed_line_color WRITE set_smoothed_line_color NOTIFY smoothed_line_color_changed)
            Q_PROPERTY(qreal peak_level READ peak_level WRITE set_peak_level NOTIFY peak_level_changed)
            Q_PROPERTY(QVariant harms_sets READ get_harms_sets NOTIFY harms_sets_changed)
            Q_PROPERTY(qreal harm_tolerance READ harm_tolerance WRITE set_harm_tolerance NOTIFY harm_tolerance_changed)
            Q_PROPERTY(qreal integral_index READ integral_index NOTIFY integral_index_changed)
            Q_PROPERTY(QJsonArray base READ base NOTIFY spec_changed)
            Q_PROPERTY(QJsonArray data READ data NOTIFY spec_changed)
            Q_PROPERTY(QJsonArray env READ env NOTIFY spec_changed)

        public:
            enum units
            {
                unit = gtl::unit,
                db = gtl::db
            };
            Q_ENUMS(units)

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


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

            QString name() const;
            int color() const;
            bool is_visible() const;

            int smoothing_factor() const;
            int smoothed_line_color() const;

            qreal peak_level() const;

            void get_smoothed_line(std::back_insert_iterator<std::vector<qreal>> data) const;
            void get_peaks(std::back_insert_iterator<std::vector<int>> peaks) const;

            QVariant get_harms_sets() const;

            int harms_sets_count() const;
            spec_harms* harms_set(uint idx) const;

            void get_harms(std::back_insert_iterator<std::vector<spec_harm*>> harms);
            void get_humps(std::back_insert_iterator<std::vector<spec_humps*>> humps);

            qreal harm_tolerance() const;

            qreal get_amplitude(qreal freq) const;

            void get_state(QJsonObject &root) const;
            void set_state(const QJsonObject &root);

            qreal integral_index() const;

            static void get_avg(int points, std::vector<qreal>::const_iterator begin, std::vector<qreal>::const_iterator end, std::back_insert_iterator<std::vector<qreal>> out);

        private:
            qreal get_y(qreal x, const std::vector<qreal> &series) const;
            QJsonArray base() const;
            QJsonArray data() const;
            QJsonArray env() const;

        private:
            QString _name;
            int _color;
            int _is_visible;

            int _smoothing_factor;
            std::vector<qreal> _smoothed_line;
            int _smoothed_line_color;

            qreal _peak_level;
            std::vector<int> _peaks;
            std::vector<qreal> _peaks_freqs;

            QList<spec_harms*> _harms_sets;
            QList<spec_humps*> _humps_sets;

            qreal _harm_tolerance;
            qreal _max_harm_level;


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

        private:
            qreal get_freq_for_max_ampl(qreal freq, qreal tolerance);
            void set_max_harm_ampl();

        public slots:
            void set_name(QString value);
            void set_color(int value);
            void set_visible(bool value);

            void set_smoothing_factor(int value);
            void set_smoothed_line_color(int value);

            void set_peak_level(qreal value);

            QJSValue add_harms_set(qreal freq, int k, int color = 0, qreal weight = 1);
            QJSValue addHarmsSet(const QJsonObject args);
            QJSValue addHumps(const QJsonObject& args);

            void clear_harms_sets();
            void clear_humps();

            void set_harm_tolerance(qreal value);

            qreal max_harm_level() const;


        private slots:
            void get_peak_freq(qreal freq, qreal tolerance, qreal &peak_freq);
            void get_ampl(qreal freq, qreal &res);
            void get_base(qreal freq, qreal &res);
            void reset();

            void get_max_harm_level(qreal &value) const;

        signals:
            void spec_changed();
            void name_changed();
            void color_changed();
            void visible_changed();
            void smoothing_factor_changed();
            void smoothed_line_color_changed();
            void peak_level_changed();
            void harms_sets_changed();
            void harm_tolerance_changed();
            void harms_set_visible_changed();
            void integral_index_changed();

            void create_engine_object(QObject*, QJSValue &);

        };
    }
}

#endif // SCR_SPEC_H