#include <QSizePolicy>
#include <QJsonDocument>

#include "gtl_gui_config_widget_analog.h"
#include "ui_gtl_gui_config_widget_analog.h"

#include "hw/gtl_analog_input.h"
#include "hw/gtl_hw_generator_analog_input.h"
#include "hw/gtl_hw_player_analog_input.h"
#include "math/gtl_math_intg.h"
#include "math/gtl_math_diff.h"
#include "gui/gtl_gui_chart_widget.h"

namespace gtl
{
    namespace gui
    {
        namespace config
        {
            widget_analog::widget_analog(QWidget *parent) :
                widget_node(parent),
                ui(new Ui::config_widget_analog),
                _filter_info(new gtl::math::filter_iir_info())
            {
                ui->setupUi(this);
                _color = new color_box(this);
                _color->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
                ui->color_layout->setWidget(0, QFormLayout::ItemRole::FieldRole, _color);

                _filter_response_chart = new config::filter_response_chart(this);
                ui->page_3->layout()->addWidget(new gtl::gui::chart_widget(_filter_response_chart));
            }

            widget_analog::~widget_analog()
            {
                delete ui;
                delete _filter_info;
            }

            void widget_analog::set_node(data_model_node *node)
            {
                _color->disconnect();
                _color->set_color(static_cast<gtl::analog_data*>(node)->color());
                connect(_color, &color_box::icolor_changed, static_cast<gtl::analog_data*>(node), &gtl::analog_data::set_color);

                QString class_name(node->metaObject()->className());
                if(class_name == "gtl::hw::analog_input")
                {
                    gtl::hw::analog_input* input = static_cast<gtl::hw::analog_input*>(node);
                    ui->stackedWidget->setCurrentIndex(0);

                    ui->sensitivity->disconnect();
                    ui->sensitivity->setValue(input->sensitivity());
                    connect(ui->sensitivity, &QDoubleSpinBox::valueChanged, input, &gtl::hw::analog_input::set_sensitivity);

                    ui->gain->disconnect();
                    ui->gain->setValue(input->gain());
                    connect(ui->gain, &QDoubleSpinBox::valueChanged, input, &gtl::hw::analog_input::set_gain);

                    ui->offset->disconnect();
                    ui->offset->setValue(input->offset());
                    connect(ui->offset, &QDoubleSpinBox::valueChanged, input, &gtl::hw::analog_input::set_offset);

                    ui->reference->disconnect();
                    ui->reference->setValue(input->reference());
                    connect(ui->reference, &QDoubleSpinBox::valueChanged, input, &gtl::hw::analog_input::set_reference);

                    ui->iepe->disconnect();
                    ui->iepe->setChecked(input->is_iepe());
                    connect(ui->iepe, &QCheckBox::stateChanged, input, &gtl::hw::analog_input::set_iepe);

                    ui->coupling->disconnect();
                    ui->coupling->setCurrentIndex(input->is_coupling());
                    connect(ui->coupling, &QComboBox::currentIndexChanged, input, &gtl::hw::analog_input::set_coupling);

                    ui->inverse->disconnect();
                    ui->inverse->setChecked(input->is_inverting());
                    connect(ui->inverse, &QCheckBox::stateChanged, input, &gtl::hw::analog_input::set_inverting);
                }
                else if(class_name == "gtl::hw::generator_analog_input")
                {
                    gtl::hw::generator_analog_input* input = static_cast<gtl::hw::generator_analog_input*>(node);
                    ui->stackedWidget->setCurrentIndex(1);

                    ui->freq->disconnect();
                    ui->freq->setValue(input->freq());
                    connect(ui->freq, &QDoubleSpinBox::valueChanged, input, &gtl::hw::generator_analog_input::set_freq);

                    ui->phase->disconnect();
                    ui->phase->setValue(input->phase());
                    connect(ui->phase, &QDoubleSpinBox::valueChanged, input, &gtl::hw::generator_analog_input::set_phase);

                }
                else if(class_name == "gtl::math::filter_iir")
                {
                    _filter = static_cast<gtl::math::filter_iir*>(node);

                    ui->stackedWidget->setCurrentIndex(2);

                    ui->filter_frequency->disconnect();
                    ui->filter_frequency->setValue(_filter->frequency());
                    connect(ui->filter_frequency, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_frequency);

                    ui->filter_order->disconnect();
                    ui->filter_order->setValue(_filter->order());
                    connect(ui->filter_order, &QSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_order);

                    ui->filter_gain->disconnect();
                    ui->filter_gain->setValue(_filter->gain());
                    connect(ui->filter_gain, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_gain);

                    ui->filter_width->disconnect();
                    ui->filter_width->setValue(_filter->width());
                    connect(ui->filter_width, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_width);

                    ui->filter_slope->disconnect();
                    ui->filter_slope->setValue(_filter->slope());
                    connect(ui->filter_slope, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_slope);

                    ui->filter_q->disconnect();
                    ui->filter_q->setValue(_filter->q());
                    connect(ui->filter_q, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_q);

                    ui->filter_ripple->disconnect();
                    ui->filter_ripple->setValue(_filter->ripple());
                    connect(ui->filter_ripple, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_ripple);

                    ui->filter_stop->disconnect();
                    ui->filter_stop->setValue(_filter->stop());
                    connect(ui->filter_stop, &QDoubleSpinBox::valueChanged, _filter, &gtl::math::filter_iir::set_stop);

                    /// set kind ///
                    ui->filter_kind->disconnect();
                    ui->filter_kind->clear();

                    for (QDomNode dom =   _filter_info->info().firstChild();
                                        !dom.isNull();
                                        dom = dom.nextSibling())
                    {
                        if (dom.isElement())
                        {
                            ui->filter_kind->addItem(dom.nodeName());
                            if( _filter->kind() == _filter_info->kind(dom.nodeName()))
                                ui->filter_kind->setCurrentIndex(ui->filter_kind->count() - 1);
                        }

                    }

                    connect(ui->filter_kind, &QComboBox::currentIndexChanged, this, &widget_analog::filter_kind_changed);
                    filter_kind_changed();


                    _filter_response_chart->set_filter(_filter);
                    ///////////////
                }
                else if(class_name == "gtl::math::intg")
                {
                    gtl::math::intg* intg = static_cast<gtl::math::intg*>(node);
                    ui->stackedWidget->setCurrentIndex(3);

                    ui->intg_taps->disconnect();
                    ui->intg_taps->setValue(intg->taps());
                    connect(ui->intg_taps, &QSpinBox::valueChanged, intg, &gtl::math::intg::set_taps);

                }
                else if(class_name == "gtl::math::diff")
                {
                    gtl::math::diff* diff = static_cast<gtl::math::diff*>(node);
                    ui->stackedWidget->setCurrentIndex(4);

                    ui->diff_taps->disconnect();
                    ui->diff_taps->setValue(diff->taps());
                    connect(ui->diff_taps, &QSpinBox::valueChanged, diff, &gtl::math::diff::set_taps);
                }
                else if(class_name == "gtl::hw::player_analog_input")
                {
                    ui->player_analog_input_info->setPlainText(QJsonDocument(static_cast<gtl::hw::player_analog_input*>(node)->info()).toJson());
                    ui->stackedWidget->setCurrentIndex(5);
                }

            }

            void widget_analog::set_color_visible(bool value)
            {
                ui->color_label->setVisible(value);
                _color->setVisible(value);
            }

            void widget_analog::filter_kind_changed()
            {
                if(_filter)
                {
                    QString name = ui->filter_kind->currentText();

                    ui->filter_type->disconnect();
                    ui->filter_type->clear();

                    QDomNode kind = _filter_info->info().namedItem(name);
                    for (QDomNode type =   kind.firstChild();
                                        !type.isNull();
                                        type = type.nextSibling())
                    {
                        if (type.isElement())
                        {
                            ui->filter_type->addItem(type.nodeName());
                            if(_filter_info->type(type.nodeName()) == _filter->type())
                                ui->filter_type->setCurrentIndex(ui->filter_type->count() - 1);
                        }
                    }
                    _filter->set_kind(_filter_info->kind(name));
                }

                connect(ui->filter_type, &QComboBox::currentIndexChanged, this, &widget_analog::filter_type_changed);
                filter_type_changed();

            }


            void widget_analog::filter_type_changed()
            {
                if(_filter)
                {
                    filter_show_property("none");
                    QDomNode kind = _filter_info->info().namedItem(ui->filter_kind->currentText());
                    QDomElement type = kind.namedItem(ui->filter_type->currentText()).toElement();

                    if(type.hasAttributes())
                        for(int i = 0; i < 6; i++)
                        {
                            QString prop = type.attribute(QString::number(i));
                            if(prop != "")
                                filter_show_property(prop);
                            else
                                break;
                        }
                    _filter->set_type(_filter_info->type(ui->filter_type->currentText()));
                }
            }

            void widget_analog::filter_show_property(QString property)
            {
                if(property == QString("gain"))
                {
                    ui->filter_gain_label->setVisible(true);
                    ui->filter_gain->setVisible(true);
                    ui->filter_gain->setValue(_filter->gain());
                }
                else if(property == QString("q"))
                {
                    ui->filter_q_label->setVisible(true);
                    ui->filter_q->setVisible(true);
                    ui->filter_q->setValue(_filter->q());
                }
                else if(property == QString("ripple"))
                {
                    ui->filter_ripple_label->setVisible(true);
                    ui->filter_ripple->setVisible(true);
                    ui->filter_ripple->setValue(_filter->ripple());
                }
                else if(property == QString("slope"))
                {
                    ui->filter_slope_label->setVisible(true);
                    ui->filter_slope->setVisible(true);
                    ui->filter_slope->setValue(_filter->slope());
                }
                else if(property == QString("stop"))
                {
                    ui->filter_stop_label->setVisible(true);
                    ui->filter_stop->setVisible(true);
                    ui->filter_stop->setValue(_filter->stop());
                }
                else if(property == QString("width"))
                {
                    ui->filter_width_label->setVisible(true);
                    ui->filter_width->setVisible(true);
                    ui->filter_width->setValue(_filter->width());
                }
                else
                {
                    ui->filter_gain_label->setVisible(false);
                    ui->filter_gain->setVisible(false);
                    ui->filter_q_label->setVisible(false);
                    ui->filter_q->setVisible(false);
                    ui->filter_ripple_label->setVisible(false);
                    ui->filter_ripple->setVisible(false);
                    ui->filter_slope_label->setVisible(false);
                    ui->filter_slope->setVisible(false);
                    ui->filter_stop_label->setVisible(false);
                    ui->filter_stop->setVisible(false);
                    ui->filter_width_label->setVisible(false);
                    ui->filter_width->setVisible(false);
                }
            }
        }
    }
}