#include "gtl_gui_player_chart.h"

namespace gtl
{
    namespace gui
    {
        namespace player
        {
            chart::chart(QWidget* parent)
                : gtl::gui::record_chart(parent)
                , _current_range(nullptr)
            {
                _ranges_menu = _menu->addMenu(tr("Ranges"));
                _menu->insertMenu(_axis_y_mode_action,  _ranges_menu);

                _add_range_action = _ranges_menu->addAction(QIcon(":/player/add_range"), tr("Add range"));
                connect(_add_range_action, &QAction::triggered, this, &chart::add_new_range);

                _remove_range_action = _ranges_menu->addAction(QIcon(":/player/remove_range"), tr("Remove range"));
                connect(_remove_range_action, &QAction::triggered, this, &chart::remove_current_range);

                _position = new chart_position(_marker_series);
                add(_position);

            }

            chart::~chart()
            {
                save_ranges();
            }

            void chart::save_ranges()
            {
                if(file() == nullptr)
                    return;

                if(_mouse_action == ::chart::add_instruments)
                    _mouse_action = ::chart::edit_instruments;

                std::vector<std::pair<qreal, qreal>> ranges;
                for(auto range : _ranges)
                    ranges.push_back(std::pair<qreal, qreal>(range->left(), range->right()));

                file()->set_ranges(ranges.begin(), ranges.end());
            }

            void chart::set_position(qreal time)
            {
                _position->set_pos((time/**file()->rate()*/));
            }

            void chart::set_file(QString path)
            {
                save_ranges();

                gtl::gui::record_chart::set_file(path);

                restore_ragnes();
            }

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

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

            chart_range *chart::get_range(QPointF pos)
            {
                for(auto range: _ranges)
                {
                    if(range->is_inside(pos))
                        return range;
                }

                return nullptr;
            }

            void chart::contextMenuEvent(QContextMenuEvent *event)
            {
                gtl::gui::record_chart::contextMenuEvent(event);

                _current_range = get_range(event->pos());

                _remove_range_action->setVisible(_current_range);
                _popup_point = event->pos();
            }

            void chart::clear_ranges()
            {
                while(!_ranges.empty())
                    remove_range(_ranges.front());
            }

            void chart::restore_ragnes()
            {
                clear_ranges();

                if(file() == nullptr)
                    return;

                std::vector<std::pair<qreal, qreal>> ranges;
                file()->get_ranges(std::back_inserter(ranges));
                for(auto range_pair: ranges)
                {
                    add_range()->set(range_pair.first, range_pair.second);
                }

            }

            void chart::remove_range(chart_range *range)
            {
                _ranges.erase(std::remove(_ranges.begin(), _ranges.end(), range), _ranges.end());
                remove(range);
                delete range;
            }

            chart_range *chart::add_range()
            {
                chart_range* range = new chart_range(_marker_series);
                connect(range, &chart_range::get_nearest_x, this, &chart::get_neares_series_x);

                add(range);
                _ranges.push_back(range);

                return range;
            }

            void chart::leaveEvent(QEvent *event)
            {
                save_ranges();
            }

            void chart::add_new_range()
            {
                _mouse_action = ::chart::add_instruments;

                add_range();

                draw_instrument(_popup_point);
            }

            void chart::remove_current_range()
            {
                remove_range(_current_range);
                _current_range = nullptr;
            }
        }
    }
}