#ifndef _DISCRETEFOURIERTRANSFORM_H
#define _DISCRETEFOURIERTRANSFORM_H

#include "plplot/plplot.h"

#include <complex>
#include <math.h>

#include <vector>

using namespace std;

template <class T, class E>
class DiscreteFourierTransform
{

public:
    /**
     * @brief Construct a new Discrete Fourier Transform object: https://docs.scipy.org/doc/scipy/tutorial/fft.html
     * @param signal_ the signal (data)
     * @param sampleSpacing  Sample spacing
     */
    DiscreteFourierTransform(vector<T> signal_, double sampleSpacing);
    /**
     * @brief Compute FFT or DFT
     *
     * @param computeFFT flag to indicate either compute FFT or DFT, default to false
     */
    void compute(bool computeFFT = false);
    /**
     * @brief Compute FFT for given signal
     *
     * @param sig signal (data)
     * @return vector<complex<E>> phasors
     */
    vector<complex<E>> fft(vector<T> sig);
    /**
     * @brief Compute DFT for given signal
     *
     * @param sig signal (data)
     * @return vector<complex<E>> phasors
     */
    vector<complex<E>> dft(vector<T> sig);
    /**
     * @brief Get only the values of Even indexes
     *
     * @param x  given array
     * @return vector<T>
     */
    vector<T> getEven(vector<T> x);
    /**
     * @brief Get only the values of Odd indexes
     *
     * @param x given array
     * @return vector<T>
     */
    vector<T> getOdd(vector<T> x);
    /**
     * @brief Compute DSP for given complex phasors
     *
     * @param x complex phasors = FFT/DFT output
     * @return vector<E>
     */
    vector<E> computeDSP(vector<complex<E>> x);
    /**
     * @brief Compute frequencies for given phasors
     *
     * @param x phasors
     * @param frequency_ sampling frequency
     * @return vector<E>
     */
    vector<E> getFreq(vector<complex<E>> x, double frequency_);
    /**
     * @brief Compute periods for given phasors
     *
     * @param x phasors
     * @param frequency_ sampling frequency
     * @return vector<E>
     */
    vector<E> getPeriods(std::vector<std::complex<E>> x, double frequency_);
    /**
     * @brief Create a vector of Points for test
     *
     * @param N size of the vector to be created
     * @param sampleSpacing_ sample spacing
     * @return vector<E>
     */
    vector<E> createTestPoints(int N, double sampleSpacing_);
    /**
     * @brief Create a Test Function
     *
     * @param x vector of points on which to compute this fucntion
     * @return vector<E>
     */
    vector<E> createTestFunction(vector<E> x);
    /**
     * @brief Check if is a power 2
     *
     * @param N integer number
     * @return true
     * @return false
     */
    bool isPowerOfTwo(int N);
    /**
     * @brief Get the smallest power of 2 number bigger than the given number
     *
     * @param n integer number
     * @return int
     */
    int highestPowerof2(int n);

    vector<complex<E>> getPhasors()
    {
        return phasors;
    }

private:
    /**
     * @brief the signal (data)
     *
     */
    vector<T> signal;
    /**
     * @brief Sample Spacing
     *
     */
    double sampleSpacing;
    /**
     * @brief a vector of a complex numbers representing a FFT result
     *
     */
    vector<complex<E>> phasors;
};

#endif