#include "gtl_gui_osc_chart.h"
#include "gtl_gui_osc_series.h"

#include "core/gtl_device.h"

namespace gtl
{
    namespace gui
    {
        namespace osc
        {
            chart::chart(QWidget* parent)
                : gtl::gui::chart(parent)
                , _time(0.01)
                , _is_triggering(false)
                , _triggering_threshold(0)
                , _triggering_is_front(true)
                , _triggering_prehistory(0.1)
                , _triggering_channel(-1)
                , _meas_model(nullptr)
                , _meas_cnt(0)
            {
                //QChartView::chart()->createDefaultAxes();
            }

            qreal chart::time() const
            {
                return _time;
            }

            bool chart::is_triggering() const
            {
                return _is_triggering;
            }

            qreal chart::triggering_threshold() const
            {
                return _triggering_threshold;
            }

            bool chart::triggering_is_front() const
            {
                return _triggering_is_front;
            }

            qreal chart::triggering_prehistory() const
            {
                return _triggering_prehistory*100;
            }

            int chart::triggering_channel() const
            {
                return _triggering_channel;
            }

            void chart::save(QDomElement &root_element)
            {
                gtl::gui::chart::save(root_element);

                root_element.setAttribute("time", _time);

                root_element.setAttribute("triggering", _is_triggering);
                root_element.setAttribute("triggering_channel", _triggering_channel);
                root_element.setAttribute("triggering_threshold", _triggering_threshold);
                root_element.setAttribute("triggering_prehistory", triggering_prehistory());
                root_element.setAttribute("triggering_is_front", _triggering_is_front);
            }

            void chart::load(const QDomElement &root_element)
            {
                gtl::gui::chart::load(root_element);

                set_time(root_element.attribute("time", "0.1").toDouble());

                set_triggering(root_element.attribute("triggering", "0").toInt() == 1);
                set_triggering_channel(root_element.attribute("triggering_channel", "-1").toInt() == 1);
                set_triggering_threshold(root_element.attribute("triggering_threshold", "0").toDouble());
                set_triggering_prehistory(root_element.attribute("triggering_prehistory", "0.1").toDouble());
                set_triggering_is_front(root_element.attribute("triggering_is_front", "1").toInt() == 1);
            }

            chart_series *chart::create_series(analog_data *ai)
            {
                series* s = new series(time(), is_updating(), ai, _axis_x, _axis_y);

                connect(s, &series::measures_changed, this, &chart::handle_measures);
                s->set_measures(_meas_model);

                return s;
            }

            void chart::set_time(qreal time)
            {
                if(time != _time)
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                        static_cast<series*>(*iter_series)->set_time(time);

                    _time = time;

                     set_bounds_x();
                     fit_axis(_axis_x);

                     emit time_changed(_time);
                }
            }

            void chart::set_triggering(bool value)
            {
                if(value != _is_triggering)
                {
                    _is_triggering = value;
                    emit triggering_changed(value);
                }
            }

            void chart::set_triggering_threshold(qreal value)
            {
                if(_triggering_threshold != value)
                {
                    _triggering_threshold = value;
                    emit triggering_threshold_changed(value);
                }
            }

            void chart::set_triggering_is_front(bool value)
            {
                if(_triggering_is_front != value)
                {
                    _triggering_is_front = value;
                    emit triggering_is_front_changed(value);
                }
            }

            void chart::set_triggering_prehistory(qreal value)
            {
                value /= 100.0;
                if(_triggering_prehistory != value)
                {
                    _triggering_prehistory = value;
                    emit triggering_prehistory_changed(value*100.0);
                }
            }

            void chart::set_triggering_channel(int value)
            {
                if(_triggering_channel != value)
                {
                    _triggering_channel = value;
                    emit triggering_channel_changed(value);
                }
            }

            void chart::set_measures(meas_model *model)
            {
                _meas_model = model;
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    static_cast<series*>(*iter_series)->set_measures(_meas_model);
            }

            void chart::handle_measures(OscMeasParamsListPtr meas)
            {
                for(int i = 0; i < meas->count(); i++)
                    for(int j = 0; j < _meas_model->measures()->count(); j++)
                    {
                        if(meas->at(i).id == _meas_model->measures()->at(j).id)
                        {
                            gtl::math::osc_meas::params *p = const_cast<gtl::math::osc_meas::params *>(&_meas_model->measures()->at(j));
                            p->value = meas->at(i).value;
                            _meas_cnt++;
                        }
                    }

                if(_meas_cnt >= _meas_model->measures()->count())
                {
                    _meas_model->all_done();
                    _meas_cnt = 0;
                }

    //            qDebug() << "osc_chart: handle_measures";
            }

            void chart::device_recieved_data()
            {
                auto it = _devices.find(static_cast<gtl::data_model_node*>(sender()));
                if(it != _devices.end())
                {
                    series* triggering_series = NULL;
                    if(_triggering_channel >= 0 && _triggering_channel < _series.size() && _is_triggering)
                        triggering_series = static_cast<series*>(_series[_triggering_channel]);

                    auto it_series = std::find(it->second.begin(), it->second.end(), triggering_series);

                    static_cast<gtl::device*>(it->first)->lock_ai();

                    if(it_series == it->second.end())
                    {
                        bool is_complete = false;
                        for(auto series : it->second)
                            is_complete |= static_cast<gtl::gui::osc::series*>(series)->update_();

                        if(is_complete && ! is_cyclic())
                            set_updating(false);
                    }
                    else
                    {
                        int ad_idx = -1;
                        bool is_complete = static_cast<series*>(*it_series)->update(_triggering_threshold, _triggering_is_front, _triggering_prehistory, ad_idx);

                        for(auto series : it->second)
                        {
                            if(series == triggering_series)
                                continue;

                            static_cast<gtl::gui::osc::series*>(series)->update(ad_idx, _triggering_prehistory);
                        }

                        if(is_complete)
                            emit acq_completed();

                        if(is_complete && ! is_cyclic())
                            set_updating(false);

                    }




                    static_cast<gtl::device*>(it->first)->unlock_ai();
                }


            }
        }
    }
}