#pragma once

#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iterator>
#include <memory>
#include <string>
#include <vector>

using std::shared_ptr;
using std::vector;

using std::cos;
using std::for_each;
using std::sin;

class Generator {
public:
    virtual float getSample() = 0;
    virtual void getSamples(size_t nSamples, float* buf);

    virtual float getFrequency() const;
    virtual void setFrequency(float _frequency);

    virtual bool isEnabled() const;
    virtual void enable();
    virtual void disable();

    virtual ~Generator();

    // disallow copy of virtual interface
    Generator(Generator const&) = delete;
    Generator& operator=(Generator const&) = delete;

protected:
    Generator(uint32_t _sampleRate, float _frequency, float _amplitude);
    uint32_t sampleRate;
    float frequency;
    float amplitude;
    bool enabled;

private:
};

class SineGenerator : public Generator {
public:
    SineGenerator(uint32_t _sampleRate, float _frequency, float _amplitude);

    float getSample() final;

    void setFrequency(float _frequency) final;

    virtual ~SineGenerator();

private:
    float instPhase;
    float phaseIncr;
};

class NoiseGenerator : public Generator {
public:
    NoiseGenerator(uint32_t _sampleRate, uint8_t rate, float _amplitude);

    float getSample() final;
    virtual ~NoiseGenerator();

    uint8_t rate;
    static const uint16_t rateTable[];

private:
    int16_t level;
    uint16_t sampleCount;
};

class SampleGenerator : public Generator {
public:
    SampleGenerator(uint32_t _sampleRate, uint16_t _playbackRate, float _amplitude, size_t nSamples, const float* samples);
    SampleGenerator(uint32_t _sampleRate, uint16_t _playbackRate, float _amplitude, size_t nSamples, const int16_t* samples);

    float getSample() final;
    virtual ~SampleGenerator();

    uint16_t playbackRate;

private:
    vector<float> sample;
    float oldest, older, old;
    uint32_t counter;
    static const uint16_t gaussTable[];
};

class SineSynth {
public:
    SineSynth(uint32_t _sampleRate);

    void addSynth(shared_ptr<Generator>);
    vector<shared_ptr<Generator>> getSynths() const;
    void clearSynths();

    void getSamples(size_t nSamples, float* buf);

private:
    uint32_t sampleRate;
    vector<shared_ptr<Generator>> generators;
};