#include "gtl_analog_data.h"

#include "gtl_device.h"

namespace gtl
{
    analog_data::analog_data(data_model_node *parent, bool is_hidden)
        :data_model_node(types::analog, parent, is_hidden)
        , _color(Qt::black)
    {

    }

    analog_data::analog_data(analog_data *parent, bool is_hidden)
            :data_model_node(types::analog, parent, is_hidden)
    {
        if(parent)
            _rate = parent->get_rate();
        else
            _rate = 100000;

        connect(parent, &analog_data::reference_changed, this, &analog_data::reference_changed);
    }

    analog_data::analog_data(qreal rate)
        :data_model_node(types::analog, nullptr, true)
    {
        _rate = rate;
    }



    void analog_data::get_data(std::back_insert_iterator<std::vector<qreal> > data)
    {
        std::copy(begin(), end(), data);
    }

    void analog_data::set_data(iterator begin, iterator end)
    {

        if(!_history.empty())
        {
            int size = (int)std::distance(begin, end);

            int idx = std::max<int>(0, size - (int)_history.size());
            while(idx != size)
            {
                int copy_size = std::min<int>(size - idx, (int)_history.size() - _history_ptr);

                std::copy(begin + idx, begin + idx + copy_size, _history.begin() + _history_ptr);

                _history_ptr = (_history_ptr + copy_size) % _history.size();
                idx += copy_size;
            }
        }

        emit data_changed();

        for(std::vector<data_model_node*>::iterator iter_node = _children.begin(); iter_node != _children.end(); iter_node++)
        {
            if((*iter_node)->type() != data_model_node::analog)
                continue;

            static_cast<analog_data*>(*iter_node)->set_data(this->begin(), this->end());
        }

        for(auto iter_node : _hidden_children)
        {
            if(iter_node->type() != data_model_node::analog)
                continue;

            static_cast<analog_data*>(iter_node)->set_data(this->begin(), this->end());
        }
    }

    void analog_data::set_rate(qreal value)
    {
        if(value != _rate)
        {

            foreach(data_model_node* child, _children)
            {
                if(child->type() == data_model_node::analog)
                {
                    static_cast<analog_data*>(child)->set_rate(value);
                }
            }
            _rate = value;
        }
    }

    void analog_data::set_color(int value)
    {
        if(value != _color)
        {
            _color = value;
            emit color_changed();
        }
    }

    qreal analog_data::get_rate() const
    {
        return _rate;
    }

    void analog_data::lock_device()
    {
        data_model_node* root_node = root();
        if(root_node == NULL)
            return;
        if(root_node->type() != data_model_node::device)
            return;

        static_cast<gtl::device*>(root_node)->lock_ai();
    }

    void analog_data::unlock_device()
    {
        data_model_node* root_node = root();
        if(root_node == NULL)
            return;
        if(root_node->type() != data_model_node::device)
            return;

        static_cast<gtl::device*>(root_node)->unlock_ai();
    }

    int analog_data::color() const
    {
        return _color;
    }

    qreal analog_data::reference() const
    {
        if(parent_node())
        {
            if(parent_node()->type() == analog)
            {
                return static_cast<gtl::analog_data*>(parent_node())->reference();
            }

        }

        return 0;
    }

    void analog_data::save(QDomElement &root_element)
    {
        data_model_node::save(root_element);

        root_element.setAttribute("color", _color);
    }

    void analog_data::load(const QDomElement &root_element)
    {
        data_model_node::load(root_element);

        _color = root_element.attribute("color", "0").toInt();
    }

    void analog_data::get_state(QJsonObject &root)
    {
        root["color"] = _color;
        data_model_node::get_state(root);
    }

    analog_data* analog_data::analog_data_root()
    {
        data_model_node* node = this;
        while(node->parent_node())
        {
            if(node->parent_node()->type() != analog)
                break;

            node = node->parent_node();
        }

        if(node->type() != analog)
            return nullptr;

        return static_cast<analog_data*>(node);
    }

    qreal analog_data::history() const
    {
        if(_rate == 0)
            return 0;

        return _history.size() / _rate;
    }

    void analog_data::set_history(qreal value)
    {
        if(_rate == 0)
            return;

        _history.resize(qRound(value*_rate));
        std::fill(_history.begin(), _history.end(), 0);
        _history_ptr = 0;

    }

    QJsonArray analog_data::getHistoryArray()
    {
        QJsonArray array;
        for(int i = 0; i < _history.size(); i++)
            array.append(_history[(_history_ptr + i)%_history.size()]);

        return array;
    }

    bool analog_data::is_checkable() const
    {
        return true;
    }
}