#include "gtl_gui_spec_chart.h"
#include "math/gtl_math_spec_meas.h"

#include "gui/spec/gtl_gui_spec_band_marker.h"
#include "gui/spec/gtl_gui_spec_harm_marker.h"

namespace gtl
{
    namespace gui
    {
        spec_chart::spec_chart(gtl::math::spec::types type, QWidget* parent)
            : chart(parent)
            , _type(type)
            , _frequency(100000)
            , _resolution(100)
            , _window(5)
            , _lines(_frequency/_resolution)
            , _average(1)
            , _overlap(0)
            , _unit(0)
            , _meas_model(nullptr)
            , _meas_cnt(0)
            , _band_markers{new spec::band_markers(this)}
            , _harm_markers{new spec::harm_markers(this)}
        {
            _band_marker_action_add = new QAction(tr("Add band marker"), this);
            _markers_menu->insertAction(_marker_action_remove, _band_marker_action_add);
            connect(_band_marker_action_add, &QAction::triggered, this, &spec_chart::add_band_marker);

            _harm_marker_action_add = new QAction(tr("Add harmonic marker"), this);
            _markers_menu->insertAction(_marker_action_remove, _harm_marker_action_add);
            connect(_harm_marker_action_add, &QAction::triggered, this, &spec_chart::add_harm_marker);
        }

        spec_chart::~spec_chart()
        {
            remove();
        }

        qreal spec_chart::frequency()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _frequency = static_cast<spec_series*>(*iter_series)->frequency();
            }
            return _frequency;
        }

        qreal spec_chart::resolution()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _resolution = static_cast<spec_series*>(*iter_series)->resolution();
            }
            return _resolution;
        }

        int spec_chart::window()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _window = static_cast<int>(static_cast<spec_series*>(*iter_series)->window());
            }
            return _window;
        }

        int spec_chart::lines()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _lines = static_cast<spec_series*>(*iter_series)->lines();
            }
            return _lines;
        }

        int spec_chart::average()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _average = static_cast<spec_series*>(*iter_series)->average();
            }
            return _average;
        }

        qreal spec_chart::overlap()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _overlap = static_cast<spec_series*>(*iter_series)->overlap();
            }
            return _overlap;
        }

        int spec_chart::unit()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _unit = static_cast<int>(static_cast<spec_series*>(*iter_series)->unit());
            }
            return _unit;
        }

        void spec_chart::save(QDomElement &root_element)
        {
            chart::save(root_element);

            root_element.setAttribute("type", _type);
            root_element.setAttribute("freq", _frequency);
            root_element.setAttribute("resolution", _resolution);
            root_element.setAttribute("window", _window);
            root_element.setAttribute("lines", _lines);
            root_element.setAttribute("avg", _average);
            root_element.setAttribute("overlap", _overlap);
            root_element.setAttribute("unit", _unit);
        }

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

            _type = (gtl::math::spec::types)root_element.attribute("type", "0").toInt();
            _frequency = root_element.attribute("freq", "100000").toDouble();
            _resolution = root_element.attribute("resolution", "100").toDouble();
            _window = root_element.attribute("window", "5").toInt();
            _lines = root_element.attribute("lines", QString::number(qRound(_frequency/_resolution))).toUInt();
            _average = root_element.attribute("avg", "1").toUInt();
            _overlap = root_element.attribute("overlap", "0").toDouble();
            _unit = root_element.attribute("unit", "0").toInt();
        }

        spec::band_markers *spec_chart::band_markers() const
        {
            return _band_markers;
        }

        spec::harm_markers *spec_chart::harm_markers() const
        {
            return _harm_markers;
        }

        void spec_chart::set_type(int value)
        {
            _type = (gtl::math::spec::types)value;

            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                static_cast<spec_series*>(*iter_series)->set_type(_type);

        }

        math::spec::types spec_chart::type() const
        {
            return _type;
        }

        void spec_chart::add_instrument(const QPointF &pos)
        {
            _instruments.back()->add(pos);
            if (_instruments.back()->is_complete())
            {
                _mouse_action = ::chart::edit_instruments;
            }
        }

        void spec_chart::draw_instrument(const QPointF &pos)
        {
            _instruments.back()->draw(QPointF(_axis_x->map_from_widget(pos.x()), _axis_y->map_from_widget(pos.y())));
        }

        void spec_chart::set_frequency(qreal value)
        {
            if(value != _frequency)
            {
                if(_series.empty())
                {
                    _frequency = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<spec_series*>(*iter_series)->set_frequency(value);
                        _frequency = static_cast<spec_series*>(*iter_series)->frequency();
                    }
                }

                emit frequency_changed();
            }
        }

        void spec_chart::set_resolution(qreal value)
        {
            if(value != _resolution)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_resolution(value);
                    _resolution = static_cast<spec_series*>(*iter_series)->resolution();
                }

                emit resolution_changed();
            }
        }

        void spec_chart::set_window(int value)
        {
            if(value != _window)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_window(value);
                    _window = static_cast<int>(static_cast<spec_series*>(*iter_series)->window() - 1);
                }

                emit window_changed();
            }
        }

        void spec_chart::set_lines(int value)
        {
            if(value != _lines)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_lines(value);
                    _lines = static_cast<spec_series*>(*iter_series)->lines();
                }

                emit lines_changed();
            }
        }

        void spec_chart::set_average(int value)
        {
            if(value != _average)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_average(value);
                    _average = static_cast<spec_series*>(*iter_series)->average();
                }

                emit average_changed();
            }
        }

        void spec_chart::set_overlap(qreal value)
        {
            if(value != _overlap)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_overlap(value);
                    _overlap = static_cast<spec_series*>(*iter_series)->overlap();
                }

                emit overlap_changed();
            }
        }

        void spec_chart::set_unit(int value)
        {
            if(value != _unit)
            {
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    static_cast<spec_series*>(*iter_series)->set_unit(value);
                    _unit = static_cast<int>(static_cast<spec_series*>(*iter_series)->unit());
                }

                emit unit_changed();
            }
        }

        void spec_chart::set_measures(spec_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<spec_series*>(*iter_series)->set_measures(_meas_model);
        }

        void spec_chart::set_x_log(bool value)
        {
            if(value)
            {
                qreal min = .001;

                for(auto series: _series)
                {
                    if(_series.size() < 2)
                        continue;

                    if(static_cast<::chart::series::xy::xy*>(series)->at_x(1) < min)
                        min = static_cast<::chart::series::xy::xy*>(series)->at_x(1);
                }


                _axis_x->set_boundaries(min, _axis_x->max_boundary());
            }
            else
                _axis_x->set_boundaries(0, _axis_x->max_boundary());

            _axis_x->set_scale(value ? ::chart::axis::logarithmic : ::chart::axis::linear);
        }

        void spec_chart::handle_measures(SpecMeasParamsListPtr 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::spec_meas::params *p = const_cast<gtl::math::spec_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;
            }
        }
        
        gtl::gui::spgr::widget* spec_chart::create_spgr(QWidget *parent, data_model_node *node)
        {
            if(node)
                for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                {
                    spec_series* ser = static_cast<spec_series*>(*iter_series);
                    if(ser->ad()->name() == node->name())
                        return ser->create_spgr(parent);
                }
            return nullptr;
        }

        void spec_chart::add_band_marker()
        {
            spec::band_marker* marker = new spec::band_marker(_marker_series, _set_theme_action->isChecked());
            add(marker);

            connect(marker, &chart_marker::get_nearest_x, this, &spec_chart::get_neares_series_x);
            connect(marker, &chart_marker::get_series_data, this, &spec_chart::get_series_data);
            connect(marker, &chart_marker::get_series_values, this, &spec_chart::get_series_values);
            connect(marker, &chart_marker::deleting, this, &spec_chart::remove_marker);

//            marker->set_pos(_mouse_pos_release);

            _markers->add_marker(marker);

            _mouse_action = ::chart::add_instruments;
            draw_instrument(_mouse_pos_release);

            _band_markers->add(marker);
        }

        void spec_chart::add_harm_marker()
        {
            chart_marker* marker = new spec::harm_marker(_marker_series, _set_theme_action->isChecked());
            add(marker);

            connect(marker, &chart_marker::get_nearest_x, this, &spec_chart::get_neares_series_x);
            connect(marker, &chart_marker::get_series_data, this, &spec_chart::get_series_data);
            connect(marker, &chart_marker::get_series_values, this, &spec_chart::get_series_values);
            connect(marker, &chart_marker::deleting, this, &spec_chart::remove_marker);

            marker->set_pos(_mouse_pos_release);

            _markers->add_marker(marker);
            _harm_markers->add(marker);
        }

        chart_series *spec_chart::create_series(analog_data *ai)
        {
            spec_series *series = new spec_series(is_updating(), _type, ai, _axis_x, _axis_y);

            connect(series, &spec_series::initialized, this, &spec_chart::set_bounds_x);
            connect(series, &spec_series::measures_changed, this, &spec_chart::handle_measures);

            series->set_frequency(_frequency);
            set_frequency(series->frequency());

            series->set_resolution(_resolution);
            series->set_window(_window);
            series->set_lines(_lines);
            series->set_average(_average);
            series->set_overlap(_overlap);
            series->set_unit(_unit);
            series->set_measures(_meas_model);

            series->update();

            return series;
        }


    }
}