#include "DistrhoPlugin.hpp"
#include <tuple>
#include <array>

class Resonator
{
public:
    Resonator():
    xp(0), xpp(0), yp(0), ypp(0), app(0), ap(0), scale(1){};

    void process(float *output, const float *const input, uint32_t frames);
    void clear();
    void set(double _app, double _ap, double _scale);

private:
    float xp;
    float xpp;
    float yp;
    float ypp;
    double app;
    double ap;
    double scale;
};

class Filter
{
public:
    Filter(){};

    void process(float **outputs, const float **inputs, uint32_t frames)
    {
        for (uint chn = 0; chn < 2; ++chn)
        {
            for (uint32_t j = 0; j < frames; ++j)
            {
                outputs[chn][j] = inputs[chn][j];
            }
            
            for (auto& r : res[chn])
            {
                r.process(outputs[chn], outputs[chn], frames);
            }
        }


    }

    //Compute filter coefficients from
    //frequency as a proportion of the sample rate
    //REMEMBER: THAT'S DOUBLE THE Nyquist RATE, dummy
    //and resonance in [0, 1]
    void set(double x, double y, double p)
    {
        double r = p * 0.99;
        double app = r * r;
        double xap = (1.0 + r * r) * cos(M_PI * x);
        double yap = (1.0 + r * r) * cos(M_PI * y);
        double scale = sqrt(0.5 - 0.5 * r * r);
        for (auto& channelFilter : res)
        {
            channelFilter[0].set(app, xap, scale);
            channelFilter[1].set(app, xap, scale);
            channelFilter[2].set(app, yap, scale);
            channelFilter[3].set(app, yap, scale);
        }
    }

private:
    std::array<std::array<Resonator, 4>, 2> res;
};