/*
  ==============================================================================

    This file was auto-generated!

    It contains the basic framework code for a JUCE plugin processor.

  ==============================================================================
*/

#pragma once

#include "../JuceLibraryCode/JuceHeader.h"
#include "PluginParameter.h"


//==============================================================================
class ProcessorBase  : public AudioProcessor
{
public:
    //==============================================================================
    ProcessorBase()  {}
    ~ProcessorBase() {}
    
    //==============================================================================
    void prepareToPlay (double, int) override {}
    void releaseResources() override {}
    void processBlock (AudioBuffer<float>&, MidiBuffer&) override {}
    
    //==============================================================================
    AudioProcessorEditor* createEditor() override          { return nullptr; }
    bool hasEditor() const override                        { return false; }
    
    //==============================================================================
    const String getName() const override                  { return {}; }
    bool acceptsMidi() const override                      { return false; }
    bool producesMidi() const override                     { return false; }
    double getTailLengthSeconds() const override           { return 0; }
    
    //==============================================================================
    int getNumPrograms() override                          { return 0; }
    int getCurrentProgram() override                       { return 0; }
    void setCurrentProgram (int) override                  {}
    const String getProgramName (int) override             { return {}; }
    void changeProgramName (int, const String&) override   {}
    
    //==============================================================================
    void getStateInformation (MemoryBlock&) override       {}
    void setStateInformation (const void*, int) override   {}
    
private:
    //==============================================================================
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ProcessorBase)
};

//==============================================================================
// Delay effect
class DelayProcessor  : public ProcessorBase
{
public:
    DelayProcessor();
    
    void prepareToPlay (double sampleRate, int samplesPerBlock) override
    {
        float maxDelayTime = 0.015f;
        delayBufferSamples = (int)(maxDelayTime * (float)sampleRate) + 1;
        if (delayBufferSamples < 1)
            delayBufferSamples = 1;
        
        delayBufferChannels = getTotalNumInputChannels();
        delayBuffer.setSize (delayBufferChannels, delayBufferSamples);
        delayBuffer.clear();
        
        delayWritePosition = 0;
    }
    
    void processBlock (AudioBuffer<float>& buffer, MidiBuffer&) override
    {
        ScopedNoDenormals noDenormals;
        auto totalNumInputChannels  = getTotalNumInputChannels();
        auto totalNumOutputChannels = getTotalNumOutputChannels();
        
        // In case we have more outputs than inputs, this code clears any output
        // channels that didn't contain input data, (because these aren't
        // guaranteed to be empty - they may contain garbage).
        // This is here to avoid people getting screaming feedback
        // when they first compile a plugin, but obviously you don't need to keep
        // this code if your algorithm always overwrites all the output channels.
        for (auto i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
            buffer.clear (i, 0, buffer.getNumSamples());
        
        float currentDelayTime = /*delayTime->getValue()*/1 / 1000 * (float)getSampleRate();
        float currentFeedback = 0.1f;
        float currentMix = 1.f;
        
        int localWritePosition;
        
        for (int channel = 0; channel < totalNumInputChannels; ++channel)
        {
            auto* channelData = buffer.getWritePointer (channel);
            float* delayData = delayBuffer.getWritePointer (channel);
            localWritePosition = delayWritePosition;
            
            for (int i = 0; i < buffer.getNumSamples(); ++i)
            {
                if (channel == 1)
                {
                    const float in = channelData[i];
                    float out = 0.0f;
                    
                    float readPosition = fmodf ((float)localWritePosition
                                                - currentDelayTime
                                                + (float)delayBufferSamples,
                                                delayBufferSamples);
                    int localReadPosition = floorf (readPosition);
                    
                    if (localReadPosition != localWritePosition)
                    {
                        float fraction = readPosition - (float)localReadPosition;
                        float delayed1 = delayData[(localReadPosition + 0)];
                        float delayed2 = delayData[(localReadPosition + 1) % delayBufferSamples];
                        out = delayed1 + fraction * (delayed2 - delayed1);
                        
                        channelData[i] = in + currentMix * (out - in);
                        delayData[localWritePosition] = in + out * currentFeedback;
                    }
                    
                    if (++localWritePosition >= delayBufferSamples)
                        localWritePosition -= delayBufferSamples;
                    
                }
            }
        }
        
        delayWritePosition = localWritePosition;
    }
    
    void reset() override
    {
    }
    
    const String getName() const override { return "Delay"; }
    
private:
    AudioBuffer<float>          delayBuffer;
    int delayBufferSamples;
    int delayBufferChannels;
    int delayWritePosition;
};

//==============================================================================
/**
*/
class SpaceDistortionAudioProcessor  : public AudioProcessor
{
public:
    //==============================================================================
    using AudioGraphIOProcessor = AudioProcessorGraph::AudioGraphIOProcessor;
    using Node = AudioProcessorGraph::Node;
    
    //==============================================================================
    SpaceDistortionAudioProcessor();
    ~SpaceDistortionAudioProcessor();

    //==============================================================================
    void prepareToPlay (double sampleRate, int samplesPerBlock) override;
    void releaseResources() override;

   #ifndef JucePlugin_PreferredChannelConfigurations
    bool isBusesLayoutSupported (const BusesLayout& layouts) const override;
   #endif

    void processBlock (AudioBuffer<float>&, MidiBuffer&) override;

    //==============================================================================
    AudioProcessorEditor* createEditor() override;
    bool hasEditor() const override;

    //==============================================================================
    const String getName() const override;
    
    bool acceptsMidi() const override;
    bool producesMidi() const override;
    bool isMidiEffect() const override;
    double getTailLengthSeconds() const override;

    //==============================================================================
    int getNumPrograms() override;
    int getCurrentProgram() override;
    void setCurrentProgram (int index) override;
    const String getProgramName (int index) override;
    void changeProgramName (int index, const String& newName) override;

    //==============================================================================
    void getStateInformation (MemoryBlock& destData) override;
    void setStateInformation (const void* data, int sizeInBytes) override;
    
    //==============================================================================
    // Delay processor
    AudioProcessorParameter*    processorDelay;
    
private:
    //==============================================================================
    // Helper functions
    void initialiseGraph();
    void connectAudioNodes();
    void connectMidiNodes();
    void updateGraph();
    
    //==============================================================================
    // Pointers for the main AudioProcessorGraph and the I/O processor nodes
    std::unique_ptr<AudioProcessorGraph> mainProcessor;
    
    Node::Ptr audioInputNode;
    Node::Ptr audioOutputNode;
    Node::Ptr midiInputNode;
    Node::Ptr midiOutputNode;
    
    Node::Ptr delayNode;
    
    //==============================================================================
    
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SpaceDistortionAudioProcessor)
};