#include "gtl_gui_spec_widget.h"
#include "gui/ui_gtl_gui_spec_widget.h"
#include "gui/gtl_gui_chart_widget.h"
#include "gui/gtl_gui_spec_meas_model.h"
#include "gui/gtl_gui_spec_meas_delegate.h"

#include "gui/gtl_gui_chart_single_markers_view.h"
#include "gui/spec/gtl_gui_spec_band_markers_view.h"
#include "gui/spec/gtl_gui_spec_harm_markers_view.h"

namespace gtl
{
    namespace gui
    {
        spec_widget::spec_widget(QWidget *parent, gtl::math::spec::types type, gtl::data_model* model) :
            QWidget(parent),
        ui(new Ui::spec_widget)
        {
            ui->setupUi(this);

            _selection_data_model = new gtl::selection_data_model(this);
            _selection_data_model->setSourceModel(model);

            ui->signals_->setModel(_selection_data_model);
            ui->signals_->expandAll();

//            ui->signals_->setContextMenuPolicy(Qt::CustomContextMenu);
//            connect(ui->signals_, &QWidget::customContextMenuRequested, this, &spec_widget::menu_request);
//            _spectrogramm_action = new QAction(tr("spectrogramm"), this);
//            connect(_spectrogramm_action, &QAction::triggered, this, &spec_widget::spectrogramm);

            _chart = new gtl::gui::spec_chart(type, this);
            gtl::gui::chart_widget *chart_widget = new gtl::gui::chart_widget(_chart, this);
            ui->splitter->insertWidget(0, chart_widget);

            connect(_selection_data_model, &gtl::selection_data_model::selected, _chart, &gtl::gui::chart::add_ad);
            connect(_selection_data_model, &gtl::selection_data_model::deselected, _chart, &gtl::gui::chart::remove_ad);

            ui->frequency->disconnect();
            ui->frequency->setMaximum(100000);
            ui->frequency->setValue(_chart->frequency());
            connect(ui->frequency, &QDoubleSpinBox::valueChanged, _chart, &gtl::gui::spec_chart::set_frequency);

            ui->resolution->disconnect();
            ui->resolution->setMaximum(100000);
            ui->resolution->setValue(_chart->resolution());
            connect(ui->resolution, &QDoubleSpinBox::valueChanged, _chart, &gtl::gui::spec_chart::set_resolution);

            ui->lines->disconnect();
            ui->lines->setMaximum(100000);
            ui->lines->setValue(_chart->lines());
            connect(ui->lines, &QDoubleSpinBox::valueChanged, _chart, &gtl::gui::spec_chart::set_lines);

            QMetaEnum meta_enum = QMetaEnum::fromType<gtl::math::spec::windows>();
            ui->window->disconnect();
            ui->window->clear();
            for(int i = 0; i < meta_enum.keyCount(); i++)
            {
                ui->window->addItem(meta_enum.valueToKey(i));
            }
//            ui->window-> addItems(_chart->windows_list());
            ui->window->setCurrentIndex(_chart->window());
            connect(ui->window, &QComboBox::currentIndexChanged, _chart, &gtl::gui::spec_chart::set_window);

            meta_enum = QMetaEnum::fromType<gtl::math::spec::types>();
            ui->type->disconnect();
            ui->type->clear();
            for(int i = 0; i < meta_enum.keyCount() - 1; i++)
                ui->type->addItem(meta_enum.valueToKey(i));
            ui->type->setCurrentIndex(_chart->type());
            connect(ui->type, &QComboBox::currentIndexChanged, _chart, &gtl::gui::spec_chart::set_type);


            ui->average->disconnect();
            ui->average->setMaximum(100);
            ui->average->setValue(_chart->average());
            connect(ui->average, &QDoubleSpinBox::valueChanged, _chart, &gtl::gui::spec_chart::set_average);

            ui->overlap->disconnect();
            ui->overlap->setMaximum(99);
            ui->overlap->setValue(_chart->overlap());
            connect(ui->overlap, &QDoubleSpinBox::valueChanged, _chart, &gtl::gui::spec_chart::set_overlap);

            ui->unit->disconnect();
            ui->unit->clear();
            ui->unit->addItem("unit");
            ui->unit->addItem("db");
//            ui->unit-> addItems(_chart->units_list());
            ui->unit->setCurrentIndex(_chart->unit());
            connect(ui->unit, &QComboBox::currentIndexChanged, _chart, &gtl::gui::spec_chart::set_unit);

            connect(_chart, &gtl::gui::spec_chart::frequency_changed, this, &gtl::gui::spec_widget::update_parameters);
            connect(_chart, &gtl::gui::spec_chart::resolution_changed, this, &gtl::gui::spec_widget::update_parameters);
            connect(_chart, &gtl::gui::spec_chart::lines_changed, this, &gtl::gui::spec_widget::update_parameters);
            connect(_chart, &gtl::gui::spec_chart::window_changed, this, &gtl::gui::spec_widget::update_parameters);

            ui->y_mode->setChecked(_chart->is_axis_y_multi());
            connect(ui->y_mode, &QCheckBox::toggled, _chart, &gtl::gui::chart::set_axis_y_mode);
            connect(_chart, &gtl::gui::chart::axis_y_mode_changed, ui->y_mode, &QCheckBox::setChecked);

            ui->x_log->setVisible(false);
            connect(ui->x_log, &QCheckBox::toggled, _chart, &gtl::gui::spec_chart::set_x_log);

            gui::spec_meas_model *meas_model = new spec_meas_model(this, _selection_data_model->selection());
            _chart->set_measures(meas_model);
            gui::spec_meas_delegate *meas_delegate = new spec_meas_delegate(this, meas_model->channels());
            _meas_widget = new gtl::gui::meas_widget(this, meas_model, meas_delegate);
            ui->tab_parameters->setVisible(false);
            ui->tab_parameters->addTab(_meas_widget, tr("Meas Parameters"));
            connect(ui->meas_check, &QCheckBox::toggled, this, &spec_widget::toogle_meas);
            connect(meas_model, &spec_meas_model::measure_changed, [=]{ _chart->set_measures(meas_model); });

//            connect(parent, &QObject::destroyed, [=]{
//                delete _chart;
//                _chart = nullptr;
//            });

            ui->tab_parameters->addTab(new chart_single_markers_view(_chart->single_markers(), this), "Single markers");
            ui->tab_parameters->addTab(new spec::band_markers_view(_chart->band_markers(), this), "Band markers");
            ui->tab_parameters->addTab(new spec::harm_markers_view(_chart->harm_markers(), this), "Harmonic markers");

        }


        spec_widget::~spec_widget()
        {
            if(_chart) delete _chart;
            if(_meas_widget) delete _meas_widget;
            delete ui;
        }

        void spec_widget::save(QDomElement &root_element)
        {
            QDomElement selection_element = root_element.ownerDocument().createElement("selection");
            root_element.appendChild(selection_element);
            _selection_data_model->save(selection_element);

            QDomElement options_element = root_element.ownerDocument().createElement("options");
            root_element.appendChild(options_element);
            _chart->save(options_element);

            QDomElement splitter_element = root_element.ownerDocument().createElement("splitter");
            root_element.appendChild(splitter_element);
            splitter_element.setAttribute("state", QString(ui->splitter->saveState().toBase64()));
        }

        void spec_widget::load(const QDomElement &root_element)
        {
            QDomElement options_element = root_element.firstChildElement("options");
            _chart->load(options_element);

            update_parameters();

            QDomElement selection_element = root_element.firstChildElement("selection");
            _selection_data_model->load(selection_element);



            QDomElement splitter_element = root_element.firstChildElement("splitter");
            ui->splitter->restoreState(QByteArray::fromBase64(splitter_element.attribute("state", "").toUtf8()));
        }

        data_model_node *spec_widget::active_node()
        {
            QModelIndex index = ui->signals_->currentIndex();

            if(index.isValid() && (index.model()->data(index, Qt::CheckStateRole) == Qt::Checked))
                return static_cast<gtl::data_model_node*>(index.internalPointer());

            return nullptr;
        }

        spgr::widget *spec_widget::create_spgr(QWidget *parent)
        {
            return create_spgr(parent, active_node());
        }

        spgr::widget *spec_widget::create_spgr(QWidget *parent, data_model_node *node)
        {
            return _chart->create_spgr(parent, node);
        }

        void spec_widget::set_type(math::spec::types type)
        {
            _chart->set_type(type);
        }

        void spec_widget::update_parameters()
        {
            ui->type->blockSignals(true);
            ui->frequency->blockSignals(true);
            ui->resolution->blockSignals(true);
            ui->lines->blockSignals(true);
            ui->window->blockSignals(true);
            ui->average->blockSignals(true);
            ui->overlap->blockSignals(true);
            ui->unit->blockSignals(true);

            if( ui->type->currentIndex() != _chart->type() )
                ui->type->setCurrentIndex(_chart->type());

            if( ui->frequency->value() != _chart->frequency() )
                ui->frequency->setValue(_chart->frequency());

            if( ui->resolution->value() != _chart->resolution() )
                ui->resolution->setValue(_chart->resolution());

            if( ui->lines->value() != (int) _chart->lines() )
                ui->lines->setValue(_chart->lines());

            if( ui->window->currentIndex() != _chart->window() )
                ui->window->setCurrentIndex(_chart->window());

            if( ui->average->value() != (int) _chart->average() )
                ui->average->setValue(_chart->average());

            if( ui->overlap->value() != (int) _chart->overlap() )
                ui->overlap->setValue(_chart->overlap());

            if( ui->unit->currentIndex() != _chart->unit() )
                ui->unit->setCurrentIndex(_chart->unit());


            ui->type->blockSignals(false);
            ui->frequency->blockSignals(false);
            ui->resolution->blockSignals(false);
            ui->lines->blockSignals(false);
            ui->window->blockSignals(false);
            ui->average->blockSignals(false);
            ui->overlap->blockSignals(false);
            ui->unit->blockSignals(false);
        }

        void spec_widget::toogle_meas(bool enabled)
        {
            ui->tab_parameters->setVisible(enabled);
            /*
            if(_meas_widget)
            {
                if(enabled)
                {
                    ui->meas_layout->addWidget(_meas_widget);
                    _meas_widget->show();
                }
                else
                {
                    ui->meas_layout->removeWidget(_meas_widget);
                    _meas_widget->hide();
                }
            }

            return;
            */
        }

//        void spec_widget::menu_request(const QPoint &pos)
//        {
//            QModelIndex index = ui->signals_->indexAt(pos);

//            if(index.model()->data(index, Qt::CheckStateRole) == Qt::Checked)
//            {
//                _popup_node = static_cast<gtl::data_model_node*>(index.internalPointer());
//                QMenu menu;
//                menu.addAction(_spectrogramm_action);
//                menu.exec(ui->signals_->viewport()->mapToGlobal(pos));
//            }
//        }

//        void spec_widget::spectrogramm()
//        {
//            gtl::gui::spgr_widget* spgr = _chart->create_spgr(this, _popup_node);
//            spgr->show();
//        }
    }
}