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

    This file contains the basic framework code for a JUCE plugin processor.

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

#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "parser/FileParser.h"
#include "parser/FrameProducer.h"
#include "audio/RotateEffect.h"
#include "audio/VectorCancellingEffect.h"
#include "audio/DistortEffect.h"
#include "audio/SmoothEffect.h"
#include "audio/BitCrushEffect.h"
#include "audio/BulgeEffect.h"
#include "audio/LuaEffect.h"
#include "audio/EffectParameter.h"

//==============================================================================
OscirenderAudioProcessor::OscirenderAudioProcessor()
#ifndef JucePlugin_PreferredChannelConfigurations
     : AudioProcessor (BusesProperties()
                     #if ! JucePlugin_IsMidiEffect
                      #if ! JucePlugin_IsSynth
                       .withInput  ("Input",  juce::AudioChannelSet::stereo(), true)
                      #endif
                       .withOutput ("Output", juce::AudioChannelSet::stereo(), true)
                     #endif
                       )
#endif
    {
    producer.startThread();
    
    juce::SpinLock::ScopedLockType lock(effectsLock);

    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<BitCrushEffect>(),
        std::vector<EffectParameter>(1, { "Bit Crush", "bitCrush", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<BulgeEffect>(),
        std::vector<EffectParameter>(1, { "Bulge", "bulge", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<RotateEffect>(),
        std::vector<EffectParameter>(1, { "2D Rotate Speed", "rotateSpeed", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<VectorCancellingEffect>(),
        std::vector<EffectParameter>(1, { "Vector cancelling", "vectorCancelling", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<DistortEffect>(true),
        std::vector<EffectParameter>(1, { "Vertical shift", "verticalDistort", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<DistortEffect>(false),
        std::vector<EffectParameter>(1, { "Horizontal shift", "horizontalDistort", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        std::make_shared<SmoothEffect>(),
        std::vector<EffectParameter>(1, { "Smoothing", "smoothing", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        wobbleEffect,
        std::vector<EffectParameter>(1, { "Wobble", "wobble", 0.0, 0.0, 1.0 })
    ));
    toggleableEffects.push_back(std::make_shared<Effect>(
        delayEffect,
        std::vector<EffectParameter>{{ "Delay Decay", "delayDecay", 0.0, 0.0, 1.0 }, { "Delay Length", "delayEchoLength", 0.5, 0.0, 1.0 }}
    ));
    toggleableEffects.push_back(traceMax);
    toggleableEffects.push_back(traceMin);

    for (auto& effect : toggleableEffects) {
        addParameter(&effect->enabled);
        effect->enabled.setValueNotifyingHost(false);
    }

    permanentEffects.push_back(frequencyEffect);
    permanentEffects.push_back(volumeEffect);
    permanentEffects.push_back(thresholdEffect);
    permanentEffects.push_back(rotateSpeed);
    permanentEffects.push_back(rotateX);
    permanentEffects.push_back(rotateY);
    permanentEffects.push_back(rotateZ);
    permanentEffects.push_back(focalLength);

    for (int i = 0; i < 5; i++) {
        addLuaSlider();
    }

    auto effects = toggleableEffects;
    effects.insert(effects.end(), permanentEffects.begin(), permanentEffects.end());
    effects.insert(effects.end(), luaEffects.begin(), luaEffects.end());

    for (auto effect : effects) {
        for (auto& parameter : effect->parameters) {
            addParameter(&parameter);
        }
    }
}

OscirenderAudioProcessor::~OscirenderAudioProcessor() {}

const juce::String OscirenderAudioProcessor::getName() const {
    return JucePlugin_Name;
}

bool OscirenderAudioProcessor::acceptsMidi() const {
   #if JucePlugin_WantsMidiInput
    return true;
   #else
    return false;
   #endif
}

bool OscirenderAudioProcessor::producesMidi() const {
   #if JucePlugin_ProducesMidiOutput
    return true;
   #else
    return false;
   #endif
}

bool OscirenderAudioProcessor::isMidiEffect() const {
   #if JucePlugin_IsMidiEffect
    return true;
   #else
    return false;
   #endif
}

double OscirenderAudioProcessor::getTailLengthSeconds() const {
    return 0.0;
}

int OscirenderAudioProcessor::getNumPrograms() {
    return 1;   // NB: some hosts don't cope very well if you tell them there are 0 programs,
                // so this should be at least 1, even if you're not really implementing programs.
}

int OscirenderAudioProcessor::getCurrentProgram() {
    return 0;
}

void OscirenderAudioProcessor::setCurrentProgram(int index) {
}

const juce::String OscirenderAudioProcessor::getProgramName(int index) {
    return {};
}

void OscirenderAudioProcessor::changeProgramName(int index, const juce::String& newName) {}

void OscirenderAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock) {
	currentSampleRate = sampleRate;
    pitchDetector.setSampleRate(sampleRate);
}

void OscirenderAudioProcessor::releaseResources() {
    // When playback stops, you can use this as an opportunity to free up any
    // spare memory, etc.
}

#ifndef JucePlugin_PreferredChannelConfigurations
bool OscirenderAudioProcessor::isBusesLayoutSupported (const BusesLayout& layouts) const
{
  #if JucePlugin_IsMidiEffect
    juce::ignoreUnused (layouts);
    return true;
  #else
    // This is the place where you check if the layout is supported.
    // In this template code we only support mono or stereo.
    // Some plugin hosts, such as certain GarageBand versions, will only
    // load plugins that support stereo bus layouts.
    if (layouts.getMainOutputChannelSet() != juce::AudioChannelSet::mono()
     && layouts.getMainOutputChannelSet() != juce::AudioChannelSet::stereo())
        return false;

    // This checks if the input layout matches the output layout
   #if ! JucePlugin_IsSynth
    if (layouts.getMainOutputChannelSet() != layouts.getMainInputChannelSet())
        return false;
   #endif

    return true;
  #endif
}
#endif

// effectsLock should be held when calling this
void OscirenderAudioProcessor::addLuaSlider() {
    juce::String sliderName = "";

    int sliderNum = luaEffects.size() + 1;
    while (sliderNum > 0) {
        int mod = (sliderNum - 1) % 26;
        sliderName = (char)(mod + 'A') + sliderName;
        sliderNum = (sliderNum - mod) / 26;
    }

    luaEffects.push_back(std::make_shared<Effect>(
        std::make_shared<LuaEffect>(sliderName, *this),
        std::vector<EffectParameter>(1, { "Lua " + sliderName, "lua" + sliderName, 0.0, 0.0, 1.0, 0.001, false })
    ));
}

// effectsLock should be held when calling this
void OscirenderAudioProcessor::updateLuaValues() {
    for (auto& effect : luaEffects) {
        effect->apply();
	}
}

// parsersLock should be held when calling this
void OscirenderAudioProcessor::updateObjValues() {
    focalLength->apply();
    rotateX->apply();
    rotateY->apply();
    rotateZ->apply();
    rotateSpeed->apply();
}

// effectsLock MUST be held when calling this
void OscirenderAudioProcessor::updateEffectPrecedence() {
    auto sortFunc = [](std::shared_ptr<Effect> a, std::shared_ptr<Effect> b) {
        return a->getPrecedence() < b->getPrecedence();
    };
    std::sort(toggleableEffects.begin(), toggleableEffects.end(), sortFunc);
}

// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::updateFileBlock(int index, std::shared_ptr<juce::MemoryBlock> block) {
    if (index < 0 || index >= fileBlocks.size()) {
		return;
	}
	fileBlocks[index] = block;
	openFile(index);
}

// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::addFile(juce::File file) {
    fileBlocks.push_back(std::make_shared<juce::MemoryBlock>());
    fileNames.push_back(file.getFileName());
	parsers.push_back(std::make_unique<FileParser>());
    file.createInputStream()->readIntoMemoryBlock(*fileBlocks.back());

    openFile(fileBlocks.size() - 1);
}

// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::addFile(juce::String fileName, const char* data, const int size) {
    fileBlocks.push_back(std::make_shared<juce::MemoryBlock>());
    fileNames.push_back(fileName);
    parsers.push_back(std::make_unique<FileParser>());
    fileBlocks.back()->append(data, size);

    openFile(fileBlocks.size() - 1);
}

// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::removeFile(int index) {
	if (index < 0 || index >= fileBlocks.size()) {
		return;
	}
    changeCurrentFile(index - 1);
    fileBlocks.erase(fileBlocks.begin() + index);
    fileNames.erase(fileNames.begin() + index);
	parsers.erase(parsers.begin() + index);
}

int OscirenderAudioProcessor::numFiles() {
    return fileBlocks.size();
}

// used for opening NEW files. Should be the default way of opening files as
// it will reparse any existing files, so it is safer.
// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::openFile(int index) {
	if (index < 0 || index >= fileBlocks.size()) {
		return;
	}
    parsers[index]->parse(fileNames[index].fromLastOccurrenceOf(".", true, false), std::make_unique<juce::MemoryInputStream>(*fileBlocks[index], false));
    changeCurrentFile(index);
}

// used ONLY for changing the current file to an EXISTING file.
// much faster than openFile(int index) because it doesn't reparse any files.
// parsersLock AND effectsLock must be locked before calling this function
void OscirenderAudioProcessor::changeCurrentFile(int index) {
    if (index == -1) {
        currentFile = -1;
        producer.setSource(std::make_shared<FileParser>(), -1);
    }
	if (index < 0 || index >= fileBlocks.size()) {
		return;
	}
	producer.setSource(parsers[index], index);
    currentFile = index;
	invalidateFrameBuffer = true;
    updateLuaValues();
    updateObjValues();
}

int OscirenderAudioProcessor::getCurrentFileIndex() {
    return currentFile;
}

std::shared_ptr<FileParser> OscirenderAudioProcessor::getCurrentFileParser() {
    return parsers[currentFile];
}

juce::String OscirenderAudioProcessor::getCurrentFileName() {
    if (currentFile == -1) {
		return "";
    } else {
        return fileNames[currentFile];
    }
}

juce::String OscirenderAudioProcessor::getFileName(int index) {
    return fileNames[index];
}

std::shared_ptr<juce::MemoryBlock> OscirenderAudioProcessor::getFileBlock(int index) {
    return fileBlocks[index];
}

void OscirenderAudioProcessor::addFrame(std::vector<std::unique_ptr<Shape>> frame, int fileIndex) {
    const auto scope = frameFifo.write(1);

    if (scope.blockSize1 > 0) {
        frameBuffer[scope.startIndex1].clear();
        for (auto& shape : frame) {
            frameBuffer[scope.startIndex1].push_back(std::move(shape));
        }
        frameBufferIndices[scope.startIndex1] = fileIndex;
    }

    if (scope.blockSize2 > 0) {
        frameBuffer[scope.startIndex2].clear();
        for (auto& shape : frame) {
            frameBuffer[scope.startIndex2].push_back(std::move(shape));
        }
        frameBufferIndices[scope.startIndex2] = fileIndex;
    }
}

void OscirenderAudioProcessor::updateFrame() {
    currentShape = 0;
    shapeDrawn = 0.0;
    frameDrawn = 0.0;
    
	if (frameFifo.getNumReady() > 0) {
        {
            const auto scope = frameFifo.read(1);

            if (scope.blockSize1 > 0) {
				frame.swap(frameBuffer[scope.startIndex1]);
                currentBufferIndex = frameBufferIndices[scope.startIndex1];
            } else if (scope.blockSize2 > 0) {
                frame.swap(frameBuffer[scope.startIndex2]);
                currentBufferIndex = frameBufferIndices[scope.startIndex2];
            }

            frameLength = Shape::totalLength(frame);
        }
    }
}

void OscirenderAudioProcessor::updateLengthIncrement() {
    double traceMaxValue = traceMaxEnabled ? actualTraceMax : 1.0;
    double traceMinValue = traceMinEnabled ? actualTraceMin : 0.0;
    double proportionalLength = (traceMaxValue - traceMinValue) * frameLength;
    lengthIncrement = juce::jmax(proportionalLength / (currentSampleRate / frequency), MIN_LENGTH_INCREMENT);
}

void OscirenderAudioProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
{
    juce::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());

    
    auto* channelData = buffer.getArrayOfWritePointers();
	auto numSamples = buffer.getNumSamples();

    if (invalidateFrameBuffer) {
        frameFifo.reset();
        // keeps getting the next frame until the frame comes from the file that we want to render.
        // this MIGHT be hacky and cause issues later down the line, but for now it works as a
        // solution to get instant changing of current file when pressing j and k.
        while (currentBufferIndex != currentFile) {
            updateFrame();
        }
        invalidateFrameBuffer = false;
    }
    
	for (auto sample = 0; sample < numSamples; ++sample) {
        updateLengthIncrement();

        traceMaxEnabled = false;
        traceMinEnabled = false;
        
        Vector2 channels;
        double x = 0.0;
        double y = 0.0;


        std::shared_ptr<FileParser> sampleParser;
        {
            juce::SpinLock::ScopedLockType lock(parsersLock);
            if (currentFile >= 0 && parsers[currentFile]->isSample()) {
                sampleParser = parsers[currentFile];
            }
        }
        bool renderingSample = sampleParser != nullptr;

        if (renderingSample) {
            channels = sampleParser->nextSample();
        } else if (currentShape < frame.size()) {
            auto& shape = frame[currentShape];
            double length = shape->length();
            double drawingProgress = length == 0.0 ? 1 : shapeDrawn / length;
            channels = shape->nextVector(drawingProgress);
        }

        {
            juce::SpinLock::ScopedLockType lock(effectsLock);
            for (auto& effect : toggleableEffects) {
                if (effect->enabled.getValue()) {
                    channels = effect->apply(sample, channels);
                }
            }
            for (auto& effect : permanentEffects) {
                channels = effect->apply(sample, channels);
            }
        }

		x = channels.x;
		y = channels.y;

        x *= volume;
        y *= volume;

        // clip
        x = juce::jmax(-threshold, juce::jmin(threshold.load(), x));
        y = juce::jmax(-threshold, juce::jmin(threshold.load(), y));
        
        if (totalNumOutputChannels >= 2) {
			channelData[0][sample] = x;
			channelData[1][sample] = y;
		} else if (totalNumOutputChannels == 1) {
            channelData[0][sample] = x;
        }

        audioProducer.write(x, y);

        actualTraceMax = juce::jmax(actualTraceMin + MIN_TRACE, juce::jmin(traceMaxValue, 1.0));
        actualTraceMin = juce::jmax(MIN_TRACE, juce::jmin(traceMinValue, actualTraceMax - MIN_TRACE));
        
        if (!renderingSample) {
            incrementShapeDrawing();
        }
        
        double drawnFrameLength = traceMaxEnabled ? actualTraceMax * frameLength : frameLength;

        if (!renderingSample && frameDrawn >= drawnFrameLength) {
            updateFrame();
            if (traceMinEnabled) {
                while (frameDrawn < actualTraceMin * frameLength) {
                    incrementShapeDrawing();
                }
            }
        }
	}
}

void OscirenderAudioProcessor::incrementShapeDrawing() {
    double length = currentShape < frame.size() ? frame[currentShape]->len : 0.0;
    // hard cap on how many times it can be over the length to
    // prevent audio stuttering
    frameDrawn += juce::jmin(lengthIncrement, 20 * length);
    shapeDrawn += juce::jmin(lengthIncrement, 20 * length);

    // Need to skip all shapes that the lengthIncrement draws over.
    // This is especially an issue when there are lots of small lines being
    // drawn.
    while (shapeDrawn > length) {
        shapeDrawn -= length;
        currentShape++;
        if (currentShape >= frame.size()) {
            currentShape = 0;
            break;
        }
        // POTENTIAL TODO: Think of a way to make this more efficient when iterating
        // this loop many times
        length = frame[currentShape]->len;
    }
}

//==============================================================================
bool OscirenderAudioProcessor::hasEditor() const
{
    return true; // (change this to false if you choose to not supply an editor)
}

juce::AudioProcessorEditor* OscirenderAudioProcessor::createEditor()
{
    return new OscirenderAudioProcessorEditor (*this);
}

//==============================================================================
void OscirenderAudioProcessor::getStateInformation (juce::MemoryBlock& destData)
{
    // You should use this method to store your parameters in the memory block.
    // You could do that either as raw data, or use the XML or ValueTree classes
    // as intermediaries to make it easy to save and load complex data.
}

void OscirenderAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
    // You should use this method to restore your parameters from this memory block,
    // whose contents will have been created by the getStateInformation() call.
}

//==============================================================================
// This creates new instances of the plugin..
juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
    return new OscirenderAudioProcessor();
}