#pragma once

#include "../Neuron.h"
#include <NeuralNetwork/ActivationFunction/Sigmoid.h>
#include <NeuralNetwork/BasisFunction/Linear.h>
#include <vector>


#include <sstream>
#include <iomanip>
#include <limits>

namespace NeuralNetwork {
namespace Recurrent {

	class Network;

	/**
	 * @author Tomas Cernik (Tom.Cernik@gmail.com)
	 * @brief Class of recurrent neuron.
	 */
	class Neuron : public NeuralNetwork::Neuron
	{
		public:
			Neuron(unsigned long _id=0,const float& _bias = 0): NeuralNetwork::Neuron(), basis(new BasisFunction::Linear),
																activation(new ActivationFunction::Sigmoid(-4.9)),
																id_(_id),bias(_bias),weights(_id+1),_output(0),_value(0) {
			}

			Neuron(const Neuron &r): NeuralNetwork::Neuron(), basis(r.basis->clone()), activation(r.activation->clone()),id_(r.id_),
									 bias(r.bias), weights(r.weights), _output(r._output), _value(r._value) {
			}
			virtual ~Neuron() {
				delete basis;
				delete activation;
			};

			virtual std::string stringify(const std::string &prefix="") const override;

			Recurrent::Neuron& operator=(const NeuralNetwork::Recurrent::Neuron&r) {
				id_=r.id_;
				bias=r.bias;
				weights=r.weights;
				basis=r.basis->clone();
				activation=r.activation->clone();
				return *this;
			}

			virtual long unsigned int id() const override {
				return id_;
			};

			/**
			 * @brief Gets weight
			 * @param n is neuron
			 */
			virtual float getWeight(const NeuralNetwork::Neuron &n) const override {
				return weights[n.id()];
			}

			/**
			 * @brief Sets weight
			 * @param n is neuron
			 * @param w is new weight for input neuron n
			 */
			virtual void setWeight(const NeuralNetwork::Neuron& n ,const float &w) override {
				if(weights.size()<n.id()+1) {
					weights.resize(n.id()+1);
				}
				weights[n.id()]=w;
			}

			/**
			 * @brief Returns output of neuron
			 */
			virtual float output() const override {
				return _output;
			}

			/**
			 * @brief Returns input of neuron
			 */
			virtual float value() const override {
				return _value;
			}

			/**
			 * @brief Function sets bias for neuron
			 * @param _bias is new bias (initial value for neuron)
			 */
			virtual void setBias(const float &_bias) override {
				bias=_bias;
			}

			/**
			 * @brief Function returns bias for neuron
			 */
			virtual float getBias() const override {
				return bias;
			}

			float operator()(const std::vector<float>& inputs) {
				//compute value
				_value=basis->operator()(weights,inputs)+bias;

				//compute output
				_output=activation->operator()(_value);

				return _output;
			}

		protected:
			BasisFunction::BasisFunction *basis;
			ActivationFunction::ActivationFunction *activation;

			unsigned long id_;
			float bias;
			std::vector<float> weights;
			float _output;
			float _value;
	};
}
}