#include "gtl_gui_osc_widget.h"
#include "ui_gtl_gui_osc_widget.h"

#include <QButtonGroup>

#include "gui/gtl_gui_chart_widget.h"
#include "gui/osc/gtl_gui_osc_meas_model.h"
#include "gui/osc/gtl_gui_osc_meas_delegate.h"

namespace gtl
{
    namespace gui
    {
        namespace osc
        {
            widget::widget(QWidget *parent, gtl::data_model* model) :
                QWidget(parent),
                ui(new Ui::osc_widget)
            {
                ui->setupUi(this);

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

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




                _chart = new chart(this);
                gtl::gui::chart_widget *chart_widget = new gtl::gui::chart_widget(_chart, this);

                _cyclic_action = new QAction(QIcon(":/osc/cycling"), tr("Cycling"), this);
                _cyclic_action->setCheckable(true);
                _cyclic_action->setChecked(_chart->is_cyclic());
                connect(_cyclic_action, &QAction::toggled, _chart, &chart::set_cyclic);
                connect(_chart, &chart::cyclic_changed, _cyclic_action, &QAction::setChecked);

                ui->cyclic->setDefaultAction(_cyclic_action);
/*
                ui->cyclic->setChecked(_chart->is_cyclic());
                connect(ui->cyclic, &QAbstractButton::toggled, _chart, &chart::set_cyclic);
                connect(_chart, &chart::cyclic_changed, ui->cyclic, &QAbstractButton::setChecked);
*/

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

                ui->num_time->setValue(_chart->time());
                connect(ui->num_time, &QDoubleSpinBox::valueChanged, _chart, &chart::set_time);
                connect(_chart, &chart::time_changed, ui->num_time, &QDoubleSpinBox::setValue);

                _updating_action = new QAction(QIcon(":/osc/updating"), tr("Updating"), this);
                _updating_action->setCheckable(true);
                _updating_action->setChecked(_chart->is_updating());
                connect(_updating_action, &QAction::toggled, _chart, &gtl::gui::chart::set_updating);
                connect(_chart, &gtl::gui::chart::updating_changed, _updating_action, &QAction::setChecked);
                ui->updating->setDefaultAction(_updating_action);
/*
                ui->updating->setChecked(_chart->is_updating());
                connect(ui->updating, &QPushButton::toggled, _chart, &gtl::gui::chart::set_updating);
                connect(_chart, &gtl::gui::chart::updating_changed, ui->updating, &QPushButton::setChecked);
*/
                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->splitter->insertWidget(0, chart_widget);

                QButtonGroup* triggering_front = new QButtonGroup(this);
                triggering_front->addButton(ui->triggering_decline, 0);
                triggering_front->addButton(ui->triggering_front, 1);


                connect(ui->triggering_button, &QCheckBox::toggled, _chart, &chart::set_triggering);
                connect(ui->triggering_button, &QCheckBox::toggled, ui->triggering, &QWidget::setVisible);
                connect(_chart, &chart::triggering_changed, ui->triggering_button, &QCheckBox::setChecked);
                ui->triggering->setVisible(false);
                ui->triggering_button->setChecked(_chart->is_triggering());


                ui->triggering_channels->setModel(_selection_data_model->selection());

                ui->triggering_channels->setCurrentIndex(_chart->triggering_channel());
                connect(ui->triggering_channels, &QComboBox::currentIndexChanged, _chart, &chart::set_triggering_channel);
                connect(_chart, &chart::triggering_channel_changed, ui->triggering_channels, &QComboBox::setCurrentIndex);

                ui->triggering_threshold->setValue(_chart->triggering_threshold());
                connect(ui->triggering_threshold, &QDoubleSpinBox::valueChanged, _chart, &chart::set_triggering_threshold);
                connect(_chart, &chart::triggering_threshold_changed, ui->triggering_threshold, &QDoubleSpinBox::setValue);

                ui->triggering_prehistory->setValue(_chart->triggering_prehistory());
                connect(ui->triggering_prehistory, &QDoubleSpinBox::valueChanged, _chart, &chart::set_triggering_prehistory);
                connect(_chart, &chart::triggering_prehistory_changed, ui->triggering_prehistory, &QDoubleSpinBox::setValue);

                ui->triggering_front->setChecked(_chart->triggering_is_front());
                connect(ui->triggering_front, &QAbstractButton::toggled, _chart, &chart::set_triggering_is_front);
                connect(_chart, &chart::triggering_is_front_changed, this, &widget::triggered_is_front_changed);

                gtl::gui::osc::meas_model *meas_model = new gtl::gui::osc::meas_model(this, _selection_data_model->selection());
                _chart->set_measures(meas_model);
                gtl::gui::osc::meas_delegate *meas_delegate = new gtl::gui::osc::meas_delegate(this, meas_model->channels());
                _meas_widget = new gtl::gui::meas_widget(this, meas_model, meas_delegate);
                connect(ui->meas_check, &QCheckBox::toggled, this, &widget::toogle_meas);
                connect(meas_model, &meas_model::measure_changed, [=]{ _chart->set_measures(meas_model); });
            }

            widget::~widget()
            {
                delete ui;
            }

            void 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("geometry", QString(ui->splitter->saveGeometry().toBase64()));
                splitter_element.setAttribute("state", QString(ui->splitter->saveState().toBase64()));
            }

            void widget::load(const QDomElement &root_element)
            {
                QDomElement selection_element = root_element.firstChildElement("selection");
                _selection_data_model->load(selection_element);

                QDomElement options_element = root_element.firstChildElement("options");
                _chart->load(options_element);

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


            }

            QAction *widget::cyclic_action() const
            {
                return _cyclic_action;
            }

            QAction *widget::updating_action() const
            {
                return _updating_action;
            }

            void widget::triggered_is_front_changed(bool value)
            {
                if(value)
                    ui->triggering_front->setChecked(true);
                else
                    ui->triggering_decline->setChecked(true);
            }

            void widget::toogle_meas(bool enabled)
            {
                if(_meas_widget)
                {
                    if(enabled)
                    {
                        ui->parameters_frame->layout()->addWidget(_meas_widget);
                        _meas_widget->show();
                    }
                    else
                    {
                        ui->parameters_frame->layout()->removeWidget(_meas_widget);
                        _meas_widget->hide();
                    }
                }

                return;
            }
        }
    }
}