/**
 * @file kernel/pdevs/qss/Integrator.hpp
 * @author The ARTIS Development Team
 * See the AUTHORS or Authors.txt file
 */

/*
 * ARTIS - the multimodeling and simulation environment
 * This file is a part of the ARTIS environment
 *
 * Copyright (C) 2013-2019 ULCO http://www.univ-littoral.fr
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef QSS_INTEGRATOR
#define QSS_INTEGRATOR

#include <artis-star/kernel/pdevs/Dynamics.hpp>
#include <artis-star/kernel/pdevs/qss/Data.hpp>

namespace artis {
    namespace pdevs {
        namespace qss {

            struct IntegratorParameters {
                double x_0;
            };

            template<class Time>
            class Integrator
                    : public artis::pdevs::Dynamics<Time, Integrator<Time>, IntegratorParameters> {
            public:
                enum inputs {
                    QUANTA = 1, X_DOT
                };

                enum outputs {
                    OUT = 1
                };

                typedef enum vars {
                    VALUE
                } Observable;

                Integrator(const std::string& name,
                        const Context<Time, Integrator<Time>, IntegratorParameters>& context)
                        :
                        artis::pdevs::Dynamics<Time, Integrator<Time>, IntegratorParameters>(name,
                                context)
                {
                    this->input_ports({{QUANTA, "quanta"},
                                       {X_DOT,  "x_dot"}});
                    this->output_port({OUT, "out"});
                    this->observable({VALUE, "value"});

                    _init_value = context.parameters().x_0;
                }

                virtual ~Integrator() { }

                virtual void dconf(typename Time::type t, typename Time::type e,
                        const common::Bag<Time>& bag)
                {
                    dint(t);
                    dext(t, e, bag);
                }

                virtual void dint(typename Time::type time)
                {
                    switch (_state) {
                    case RUNNING: {
                        record_t record;
                        double last_derivative_value = _archive.back().x_dot;

                        _last_output_value = _expected_value;
                        _last_output_date = time;
                        _archive.clear();
                        record.date = time;
                        record.x_dot = last_derivative_value;
                        _archive.push_back(record);
                        _current_value = _expected_value;
                        _state = WAIT_FOR_QUANTA;
                        break;
                    }
                    case INIT: {
                        _state = WAIT_FOR_BOTH;
                        _last_output_value = _current_value;
                        _last_output_date = time;
                        break;
                    }
                    default:
                        assert(false);
                    }
                }

                virtual void dext(typename Time::type t, typename Time::type e,
                        const common::Bag<Time>& bag)
                {
                    std::for_each(bag.begin(), bag.end(),
                            [this, t, e](const common::ExternalEvent<Time>& event) {
                                if (event.on_port(QUANTA)) {
                                    QuantifierData data;

                                    event.data()(data);
                                    _up_threshold = data.up;
                                    _down_threshold = data.down;
                                    if (_state == WAIT_FOR_QUANTA) {
                                        _state = RUNNING;
                                    }
                                    if (_state == WAIT_FOR_BOTH) {
                                        _state = WAIT_FOR_X_DOT;
                                    }
                                }
                                if (event.on_port(X_DOT)) {
                                    DerivativeData data;
                                    record_t record;

                                    event.data()(data);
                                    record.date = t;
                                    record.x_dot = data.x_dot;
                                    _archive.push_back(record);
                                    if (_state == WAIT_FOR_X_DOT) {
                                        _state = RUNNING;
                                    }
                                    if (_state == WAIT_FOR_BOTH) {
                                        _state = WAIT_FOR_QUANTA;
                                    }
                                }
                            });
                    if (_state == RUNNING) {
                        _current_value = current_value(t);
                        _expected_value = expected_value(t);
                    }
                }

                virtual typename Time::type start(typename Time::type /* time */)
                {
                    _current_value = _init_value;
                    _state = INIT;
                    return 0;
                }

                virtual typename Time::type ta(typename Time::type /* time */)
                {
                    double current_derivative;

                    switch (_state) {
                    case RUNNING:

                        assert(_archive.size() > 0);

                        current_derivative = _archive.back().x_dot;
                        if (current_derivative == 0) {
                            return Time::infinity;
                        }
                        if (current_derivative > 0) {

                            assert(_up_threshold - _current_value >= 0);

                            return (_up_threshold - _current_value) / current_derivative;
                        } else {

                            assert(_down_threshold - _current_value <= 0);

                            return (_down_threshold - _current_value) / current_derivative;
                        }
                    default:
                        return Time::infinity;
                    }
                }

                virtual common::Bag<Time> lambda(typename Time::type /* time */) const
                {
                    common::Bag<Time> msgs;

                    switch (_state) {
                    case RUNNING: {
                        const IntegratorData data = {_expected_value};

                        msgs.push_back(common::ExternalEvent<Time>(OUT, data));
                        break;
                    }
                    case INIT: {
                        const IntegratorData data = {_current_value};

                        msgs.push_back(common::ExternalEvent<Time>(OUT, data));
                        break;
                    }
                    default:
                        break;
                    }
                    return msgs;
                }

                virtual common::Value observe(const typename Time::type& /* t */,
                        unsigned int index) const
                {
                    switch (index) {
                    case VALUE:
                        return (double) (_current_value);
                    default:
                        return common::Value();
                    }
                }

            private:
                double current_value(const typename Time::type& time) const
                {
                    double val = _last_output_value;

                    if (_archive.size() > 0) {
                        for (size_t i = 0; i < _archive.size() - 1; i++) {
                            val +=
                                    (_archive[i + 1].date - _archive[i].date) * _archive[i].x_dot;
                        }
                        val += (time - _archive.back().date) * _archive.back().x_dot;
                    }
                    return val;
                }

                double expected_value(const typename Time::type& /* time */) const
                {
                    double current_derivative = _archive.back().x_dot;

                    if (current_derivative == 0) {
                        return _current_value;
                    } else if (current_derivative > 0) {
                        return _up_threshold;
                    }
                    return _down_threshold;
                }

                typedef enum {
                    INIT,
                    WAIT_FOR_QUANTA,
                    WAIT_FOR_X_DOT,
                    WAIT_FOR_BOTH,
                    RUNNING
                } State;

                struct record_t {
                    double x_dot;
                    typename Time::type date;
                };

                State _state;

                typename Time::type _last_output_date;

                double _up_threshold;
                double _down_threshold;

                double _last_output_value;
                double _init_value;
                double _current_value;
                double _expected_value;

                std::deque<record_t> _archive;
            };

        }
    }
}

#endif