#ifndef GTL_GUI_ORBIT_SERIES_H
#define GTL_GUI_ORBIT_SERIES_H

#include "chart/series/series.h"
#include "core/gtl_analog_data.h"
#include "core/gtl_device.h"
#include "math/gtl_math_freq.h"
#include "gui/gui_global.h"
#include <queue>

namespace gtl {
    namespace gui {
        namespace orbit {

            class GTL_GUI_EXPORT series : public ::chart::series::series
            {
                Q_OBJECT

//                Q_PROPERTY(gtl::analog_data *x READ x WRITE set_x NOTIFY x_changed)
//                Q_PROPERTY(gtl::analog_data *y READ y WRITE set_y NOTIFY y_changed)
//                Q_PROPERTY(qreal time READ time WRITE set_time NOTIFY time_changed)
//                Q_PROPERTY(qreal start READ start WRITE set_start NOTIFY start_changed)
//                Q_PROPERTY(qreal stop READ stop WRITE set_stop NOTIFY stop_changed)
//                Q_PROPERTY(qreal turns READ turns WRITE set_turns NOTIFY turns_changed)

            public:
                series(QWidget* parent, ::chart::axis_horz* axis_x, ::chart::axis_vert* axis_y);
                ~series();

                virtual void save(QDomElement& root_element);
                virtual void load(const QDomElement& root_element);

                void set_updating(bool value);
//                gtl::analog_data* ad();
                void autoscale();
                void set_pos(QPointF pos);

                virtual QString name() const;
                virtual void set_tool_tip(QPoint pos);

                virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);

                virtual bool get_range_y(qreal x_min, qreal x_max, qreal &y_min, qreal &y_max){return true;}
                virtual bool get_ranges(qreal &x_min, qreal &x_max, qreal &y_min, qreal &y_max){return true;}
                virtual bool get_tool_tip(QPoint pos, QString &text, QRect &rect){return true;}

                gtl::analog_data* x() const;
                void set_x(gtl::analog_data *value);
                gtl::analog_data* y() const;
                void set_y(gtl::analog_data *value);
                qreal time() const;
                void set_time(qreal value);
                qreal start() const;
                void set_start(qreal value);
                qreal stop() const;
                void set_stop(qreal value);
                qreal turns() const;
                void set_turns(qreal value);
                qreal freq() const;

                std::vector<QPointF>::iterator points_begin(){ return _points.begin(); }
                std::vector<QPointF>::iterator points_end(){ return _points.end(); }
                QColor color();

            private:
                gtl::analog_data* _x;
                gtl::analog_data* _y;
                qreal _time;
                qreal _start;
                qreal _stop;
                qreal _turns;

                bool _is_updating;
                qreal _max;
                gtl::device* _device;
                gtl::math::freq* _freq;
                std::vector<qreal> _data_x;
                std::vector<qreal> _data_y;
                unsigned long _samples_x;
                unsigned long _samples_y;
                std::vector<QPointF> _points;
                int _size;

            private slots:
                void update_series();
                void set_icolor();
                void handle_x_changed();
                void handle_y_changed();
                void init();

            signals:
                void x_changed();
                void y_changed();
                void time_changed();
                void start_changed();
                void stop_changed();
                void turns_changed();
                void freq_changed();
            };

        } // namespace orbit
    } // namespace gui
} // namespace gtl

#endif // GTL_GUI_ORBIT_SERIES_H