#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);
    vector<T> getEven(vector<T> x);
    vector<T> getOdd(vector<T> x);
    vector<E> computeDSP(vector<complex<E>> x);
    vector<E> getFreq(vector<complex<E>> x, double sampleSpacing_);
    vector<E> getPeriods(std::vector<std::complex<E>> x, double sampleSpacing_);
    vector<E> createTestPoints(int N, double sampleSpacing_);
    vector<E> createTestFunction(vector<E> x);
    bool isPowerOfTwo(int N);
    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