#pragma once

#include "Eigen/Dense"
#include <complex>

#ifndef CONTROL_H
#define CONTROL_H


namespace ct
{
	// Fwd declarations
	template<typename T, int n, int m, int k> struct SSModel;
	template<typename T, int p, int z> struct TransferFn;

	namespace math
	{
		template<typename T, int n, int m>
		Eigen::Vector<T, n + m - 1> convolve1d(
				const Eigen::Ref<Eigen::Vector<T, n>>& x
				const Eigen::Ref<Eigen::Vector<T, m>>& y)
		{
			Eigen::Vector<T, n + m -1> out;

			return out;
		}

		Eigen::VectorXd convolve1d(
				const Eigen::Ref<Eigen::VectorXd>& x,
				const Eigen::Ref<Eigen::VectorXd>& y)
		{
			
		}
	}

	/* Transfer Functions for SISO and frequency domain analysis */
	template<typename T, int p, int z>
	struct TransferFn
	{
		Eigen::Vector<std::complex<T>, z> zeros;
		Eigen::Vector<std::complex<T>, p> poles;

		explicit operator SSModel<T, p, 1, 1>() const
		{
			
		}
	};

	typedef TransferFn<std::complex<double>, Eigen::Dynamic, Eigen::Dynamic> TransferFnXd;

	template<typename T, typename CT = std::complex<T>>
	struct FreqSeries
	{
		size_t nsamples;
		T start, end;
		Eigen::VectorX<T> f;
		Eigen::VectorX<CT> data;
	};

	typedef FreqSeries<double> FreqSeriesD;

	/* State space modelling and time domain simulaiton */

	template<typename T, int n, int m, int k>
	struct SSModel
	{
		/* State space model with
		 * - n dimensional state x
		 * - m dimensional input u
		 * - k dimensional output y
		 */
		Eigen::Matrix<T, n, n> A;
		Eigen::Matrix<T, n, m> B;
		Eigen::Matrix<T, k, m> C;
		Eigen::Matrix<T, k, m> D;

		// SSModel(Eigen::VectorX<T> zeros, Eigen::VectorX<T> poles);
	};

	typedef SSModel<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic> SSModelXd;

	template<typename T>
	struct TimeSeries
	{
		size_t nsamples;
		T start, end;
		Eigen::VectorX<T> t;
		Eigen::MatrixX<T> u, x, y;

		template<int n, int m, int k>
		explicit TimeSeries(size_t nsamples, T start, T end, const SSModel<T, n, m, k>& ss);
	};

	typedef TimeSeries<double> TimeSeriesD;

	template<typename T, int n, int m, int k>
	void response(SSModel<T, n, m, k> ss, TimeSeries<T>& ts);

	template<typename T, int n, int m, int k>
	void step(SSModel<T, n, m, k> ss, TimeSeries<T>& ts);
}

#endif // CONTROL_H
// vim:ts=2 sw=2 noet: