#ifndef _DISCRETEFOURIERTRANSFORM_H
#define _DISCRETEFOURIERTRANSFORM_H

#include <math.h>
#include <vector>

#define PI 3.14159265

using namespace std;

template <class T, class E>

/**
 * @brief Une classe qui reprèsente une transformée de Fourier discrète (DFT) à appliquer pour
 * un signal numérique donné. Pour calculer la TFD, il est nécessaire d’avoir une bonne notation, et de bien comprendre tous les éléments qui entrent en jeu :
    Le nombre total d’échantillons (points qu’on a mesurés) est noté nbEchantillons (N)
    Pour avoir des échantillons, il faut une fréquence d’échantillonnage fe (Fe)
    On note s(k) la valeur du signal échantillonné pour le point k
    Nous pouvons, au maximum, calculer nbEchantillons valeurs de Fourier. Le nom choisi pour ces valeurs (allant de 0 à N) est k.
    Et à chacune de ces valeurs correspond une fréquence noté fk
    La valeur de Fourier pour un k donné est noté S(k) (et il s’agit d’un nombre complexe)

    @see http://gobgob-technology.fr/cours/tfd/, https://www.geeksforgeeks.org/discrete-fourier-transform-and-its-inverse-using-c/
 *
 */
class DiscreteFourierTransform
{

public:
    /**
     * @brief Construct a new Discrete Fourier Transform object
     *
     * @param nbEchantillons_ Le nombre total d’échantillons
     * @param signal_ Le signal à échantillonner
     * @param frequenceEchantillonnage_ La fréquence d’échantillonnage
     */
    DiscreteFourierTransform(int nbEchantillons_, vector<T> signal_, double frequenceEchantillonnage_);

    /**
     * @brief Calcul de la TFD
     *
     */
    void compute();

    /**
     * @brief Get the Amplitudes object
     *
     * @return vector<E>
     */
    vector<E> getAmplitudes()
    {
        return amplitudes;
    }

    /**
     * @brief Get the Frequences object
     *
     * @return vector<E>
     */
    vector<E> getFrequences()
    {
        return frequences;
    }

    /**
     * @brief Get the Phases object
     *
     * @return vector<E>
     */
    vector<E> getPhases()
    {
        return phases;
    }

    /**
     * @brief Get the Periodes object
     *
     * @return vector<E>
     */
    vector<E> getPeriodes()
    {
        return periodes;
    }

private:
    /**
     * @brief Le nombre total d’échantillons (points qu’on a mesurés)
     *
     */
    int nbEchantillons;
    /**
     * @brief le signal numérique dont on cherche à calculer la DFT
     *
     */
    vector<T> signal;
    /**
     * @brief Pour avoir des échantillons, il faut une fréquence d’échantillonnage Fe
     *
     */
    double frequenceEchantillonnage;
    /**
     * @brief L’amplitude fréquentielle (la valeur qui nous intéresse) est le module de la valeur complexe : ∥S(k)∥
     *
     */
    vector<E> amplitudes;
    /**
     * @brief La phase fréquentielle est l'argument de la valeur complexe : S(k)
     *
     */
    vector<E> phases;
    /**
     * @brief Les valeurs des fréquences fk
     *
     */
    vector<E> frequences;
    /**
     * @brief Les valeurs des periodes 1/fk
     *
     */
    vector<E> periodes;
};

#endif