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

This file was auto-generated!

It contains the basic startup code for a Juce application.

==============================================================================
*/
#include "PluginProcessor.h"
#include "PluginEditor.h"
#include "Engine/Params.h"

// Compare JUCE_VERSION against this to check for JUCE 5.4.3 and earlier
#define JUCE_543 328707

//only sse2 version on windows
#ifdef _WINDOWS
#define __SSE2__
#define __SSE__
#endif

#ifdef __SSE2__
#include <xmmintrin.h>
#endif

//==============================================================================
#define S(T) (juce::String(T))

//==============================================================================
AudioProcessorValueTreeState::ParameterLayout createParameterLayout()
{
    ObxdParams defaultParams;
    std::vector<std::unique_ptr<AudioParameterFloat>> params;
    
    for (int i = 0; i < PARAM_COUNT; ++i)
    {
        auto id           = ObxdAudioProcessor::getEngineParameterId (i);
        auto name         = TRANS (id);
        auto range        = NormalisableRange<float> {0.0f, 1.0f};
        auto defaultValue = defaultParams.values[i];
        auto parameter    = std::make_unique<AudioParameterFloat> (
            ParameterID{ id, 1 }, name, range, defaultValue, String{}, AudioProcessorParameter::genericParameter,
            [=](float value, int /*maxStringLength*/)
            {
                return ObxdAudioProcessor::getTrueParameterValueFromNormalizedRange(i, value);
            });
        
        params.push_back (std::move (parameter));
    }
    
    return { params.begin(), params.end() };
}

//==============================================================================
ObxdAudioProcessor::ObxdAudioProcessor()
	: bindings()
	, programs()
	, configLock("__" JucePlugin_Name "ConfigLock__")
    , apvtState (*this, &undoManager, "PARAMETERS", createParameterLayout())
{
	isHostAutomatedChange = true;
	midiControlledParamSet = false;
	lastMovedController = 0;
	lastUsedParameter = 0;

	synth.setSampleRate (44100);
    
	PropertiesFile::Options options;
	options.applicationName = JucePlugin_Name;
	options.storageFormat = PropertiesFile::storeAsXML;
	options.millisecondsBeforeSaving = 2500;
	options.processLock = &configLock;
    config = std::unique_ptr<PropertiesFile> (new PropertiesFile (getDocumentFolder().getChildFile ("Skin.xml"), options));
    showPresetBar = config->getBoolValue("presetnavigation");
    gui_size = config->getIntValue("gui_size", 1);
    tooltipBehavior = static_cast<Tooltip>(config->getIntValue("tooltip", 1));
	currentSkin = config->containsKey("skin") ? config->getValue("skin") : "Ilkka Rosma Dark";
	currentBank = "000 - FMR OB-Xa Patch Book";

	scanAndUpdateBanks();
    scanAndUpdateSkins();
    initAllParams();

	if (bankFiles.size() > 0)
	{
		loadFromFXBFile (bankFiles[0]);
	}
    
    for (int i = 0; i < PARAM_COUNT; ++i)
    {
        apvtState.addParameterListener (getEngineParameterId (i), this);
    }
    
    apvtState.state = ValueTree (JucePlugin_Name);
    initMidi();
}

ObxdAudioProcessor::~ObxdAudioProcessor()
{
    
	config->saveIfNeeded();
	config = nullptr;
}

//==============================================================================
void ObxdAudioProcessor::initAllParams()
{
    for (int i = 0; i < PARAM_COUNT; ++i)
    {
        setEngineParameterValue (i, programs.currentProgramPtr->values[i], true);
    }
}

//==============================================================================
const String ObxdAudioProcessor::getName() const
{
	return JucePlugin_Name;
}

const String ObxdAudioProcessor::getInputChannelName (int channelIndex) const
{
	return String (channelIndex + 1);
}

const String ObxdAudioProcessor::getOutputChannelName (int channelIndex) const
{
	return String (channelIndex + 1);
}

bool ObxdAudioProcessor::isInputChannelStereoPair (int index) const
{
	return true;
}

bool ObxdAudioProcessor::isOutputChannelStereoPair (int index) const
{
	return true;
}

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

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

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

//==============================================================================
int ObxdAudioProcessor::getNumPrograms()
{
	return PROGRAMCOUNT;
}

int ObxdAudioProcessor::getCurrentProgram()
{
	return programs.currentProgram;
}

void ObxdAudioProcessor::setCurrentProgram (int index, bool updateHost){
    programs.currentProgram = index;
    programs.currentProgramPtr = programs.programs + programs.currentProgram;
    isHostAutomatedChange = false;
    
    for (int i = 0; i < PARAM_COUNT; ++i)
        setEngineParameterValue (i, programs.currentProgramPtr->values[i], true);
    
    isHostAutomatedChange = true;
    
    sendChangeMessage();
    // Will delay
    if (updateHost) {
        updateHostDisplay();
    }
}

void ObxdAudioProcessor::setCurrentProgram (int index)
{
	programs.currentProgram = index;
	programs.currentProgramPtr = programs.programs + programs.currentProgram;
	isHostAutomatedChange = false;
    
	for (int i = 0; i < PARAM_COUNT; ++i)
		setEngineParameterValue (i, programs.currentProgramPtr->values[i], true);
    
	isHostAutomatedChange = true;
	sendChangeMessage();
	updateHostDisplay();
}

const String ObxdAudioProcessor::getProgramName (int index)
{
	return programs.programs[index].name;
}

void ObxdAudioProcessor::changeProgramName (int index, const String& newName)
{
	 programs.programs[index].name = newName;
}

//==============================================================================
void ObxdAudioProcessor::prepareToPlay (double sampleRate, int /*samplesPerBlock*/)
{
	// Use this method as the place to do any pre-playback
	// initialisation that you need..
	nextMidi = new MidiMessage (0xF0);
	midiMsg  = new MidiMessage (0xF0);
	synth.setSampleRate (sampleRate);
}

void ObxdAudioProcessor::releaseResources()
{
}

inline void ObxdAudioProcessor::processMidiPerSample (MidiBuffer::Iterator* iter, const int samplePos)
{
	while (getNextEvent (iter, samplePos))
	{
		if (midiMsg->isNoteOn())
		{
			synth.procNoteOn (midiMsg->getNoteNumber(), midiMsg->getFloatVelocity());
		}
		if (midiMsg->isNoteOff())
		{
			synth.procNoteOff (midiMsg->getNoteNumber());
		}
		if (midiMsg->isPitchWheel())
		{
			// [0..16383] center = 8192;
			synth.procPitchWheel ((midiMsg->getPitchWheelValue() - 8192) / 8192.0f);
		}
		if (midiMsg->isController() && midiMsg->getControllerNumber() == 1)
        {
			synth.procModWheel (midiMsg->getControllerValue() / 127.0f);
        }
		if(midiMsg->isSustainPedalOn())
		{
			synth.sustainOn();
		}
		if(midiMsg->isSustainPedalOff() || midiMsg->isAllNotesOff()||midiMsg->isAllSoundOff())
		{
			synth.sustainOff();
		}
		if(midiMsg->isAllNotesOff())
		{
			synth.allNotesOff();
		}
		if(midiMsg->isAllSoundOff())
		{
			synth.allSoundOff();
        }
        
        DBG(" Message: " << midiMsg->getChannel() << " "<<midiMsg->getRawData()[0] << " "<< midiMsg->getRawData()[1] << " "<< midiMsg->getRawData()[2]);
        
        if (midiMsg->isProgramChange()){ // xC0
            setCurrentProgram(midiMsg->getProgramChangeNumber());
            
        } else
        if (midiMsg->isController()) // xB0
        {
            lastMovedController = midiMsg->getControllerNumber();
            if (programs.currentProgramPtr->values[MIDILEARN] > 0.5f){
                midiControlledParamSet = true;
                //bindings[lastMovedController] = lastUsedParameter;
                bindings.updateCC(lastUsedParameter, lastMovedController);
                File midi_file = getMidiFolder().getChildFile("Custom.xml");
                bindings.saveFile(midi_file);
                currentMidiPath = midi_file.getFullPathName();
                
                setEngineParameterValue (MIDILEARN, 0, true);
                lastMovedController = 0;
                lastUsedParameter = 0;
                midiControlledParamSet = false;
                
                
            }

            if (bindings[lastMovedController] > 0)
            {
                midiControlledParamSet = true;
                setEngineParameterValue (bindings[lastMovedController],
                                         midiMsg->getControllerValue() / 127.0f, true);
                
                setEngineParameterValue (MIDILEARN, 0, true);
                lastMovedController = 0;
                lastUsedParameter = 0;

                midiControlledParamSet = false;
            }
        }
	}
}

bool ObxdAudioProcessor::getNextEvent (MidiBuffer::Iterator* iter, const int samplePos)
{
	if (hasMidiMessage && midiEventPos <= samplePos)
	{
		*midiMsg = *nextMidi;
		hasMidiMessage = iter->getNextEvent (*nextMidi, midiEventPos);
		return true;
	}
    
	return false;
}

void ObxdAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
	//SSE flags set
#ifdef __SSE__
	_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
#endif
#ifdef __SSE2__
	// _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
#endif

	MidiBuffer::Iterator ppp (midiMessages);
	hasMidiMessage = ppp.getNextEvent (*nextMidi, midiEventPos);

	int samplePos = 0;
	int numSamples = buffer.getNumSamples();
	float* channelData1 = buffer.getWritePointer (0);
	float* channelData2 = buffer.getWritePointer (1);

	AudioPlayHead::CurrentPositionInfo pos;
    
    if (getPlayHead() != 0 && getPlayHead()->getCurrentPosition (pos))
    {
		synth.setPlayHead(pos.bpm, pos.ppqPosition);
    }

	while (samplePos < numSamples)
	{
		processMidiPerSample (&ppp, samplePos);
		synth.processSample (channelData1+samplePos, channelData2+samplePos);
		++samplePos;
	}
}

//==============================================================================
bool ObxdAudioProcessor::hasEditor() const
{
	return true;
}

AudioProcessorEditor* ObxdAudioProcessor::createEditor()
{
	return new ObxdAudioProcessorEditor (*this);
}

//==============================================================================
void ObxdAudioProcessor::getStateInformation(MemoryBlock& destData)
{
	XmlElement xmlState = XmlElement("discoDSP");
	xmlState.setAttribute(S("currentProgram"), programs.currentProgram);

	XmlElement* xprogs = new XmlElement("programs");
	for (int i = 0; i < PROGRAMCOUNT; ++i)
	{
		XmlElement* xpr = new XmlElement("program");
		xpr->setAttribute(S("programName"), programs.programs[i].name);
		xpr->setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);

		for (int k = 0; k < PARAM_COUNT; ++k)
		{
            xpr->setAttribute("Val_" + String(k), programs.programs[i].values[k]);
		}

		xprogs->addChildElement(xpr);
	}

	xmlState.addChildElement(xprogs);

    //bindings.setXml(xmlState);

	copyXmlToBinary(xmlState, destData);
}

void ObxdAudioProcessor::getCurrentProgramStateInformation(MemoryBlock& destData)
{
	XmlElement xmlState = XmlElement("discoDSP");

	for (int k = 0; k < PARAM_COUNT; ++k)
	{
		xmlState.setAttribute("Val_" + String(k), programs.currentProgramPtr->values[k]);
	}

	xmlState.setAttribute(S("voiceCount"), Motherboard::MAX_VOICES);
	xmlState.setAttribute(S("programName"), programs.currentProgramPtr->name);

	copyXmlToBinary(xmlState, destData);
}

void ObxdAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
	XmlElement * const xmlState = getXmlFromBinary(data, sizeInBytes);
#else
	std::unique_ptr<XmlElement> xmlState = getXmlFromBinary(data, sizeInBytes);
#endif
    
    DBG(" XML:" << xmlState->toString());
	if (xmlState)
	{
		XmlElement* xprogs = xmlState->getFirstChildElement();
		if (xprogs && xprogs->hasTagName(S("programs")))
		{
			int i = 0;
			forEachXmlChildElement(*xprogs, e)
			{
				bool newFormat = e->hasAttribute("voiceCount");
				programs.programs[i].setDefaultValues();

				for (int k = 0; k < PARAM_COUNT; ++k)
				{
                    float value = 0.0;
                    if (e->hasAttribute("Val_" + String(k))){
                        value = float(e->getDoubleAttribute("Val_" + String(k), programs.programs[i].values[k]));
                    } else {
                        value = float(e->getDoubleAttribute(String(k), programs.programs[i].values[k]));
                    }
                    
					if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
					programs.programs[i].values[k] = value;
				}

				programs.programs[i].name = e->getStringAttribute(S("programName"), S("Default"));

				++i;
				}
			}

		//bindings.getXml(*xmlState);
#if ! DEMOVERSION
		setCurrentProgram(xmlState->getIntAttribute(S("currentProgram"), 0));

        sendChangeMessage();
#endif
#if JUCE_VERSION <= JUCE_543
		delete xmlState;
#endif
		}
	}

void  ObxdAudioProcessor::setCurrentProgramStateInformation(const void* data, int sizeInBytes)
{
#if JUCE_VERSION <= JUCE_543
	XmlElement * const e = getXmlFromBinary(data, sizeInBytes);
#else
	std::unique_ptr<XmlElement> e = getXmlFromBinary(data, sizeInBytes);
#endif
	if (e)
	{
		programs.currentProgramPtr->setDefaultValues();

		bool newFormat = e->hasAttribute("voiceCount");
		for (int k = 0; k < PARAM_COUNT; ++k)
		{
            float value = 0.0 ;
            if (e->hasAttribute("Val_" + String(k))){
                value = float(e->getDoubleAttribute("Val_" + String(k), programs.currentProgramPtr->values[k]));
            } else {
                value = float(e->getDoubleAttribute(String(k), programs.currentProgramPtr->values[k]));
            }
			 
			if (!newFormat && k == VOICE_COUNT) value *= 0.25f;
			programs.currentProgramPtr->values[k] = value;
		}

		programs.currentProgramPtr->name = e->getStringAttribute(S("programName"), S("Default"));

		setCurrentProgram(programs.currentProgram);
        
        sendChangeMessage();
#if JUCE_VERSION <= JUCE_543
		delete e;
#endif
	}
}

//==============================================================================
bool ObxdAudioProcessor::deleteBank() {
    currentBankFile.deleteFile();
    scanAndUpdateBanks();
    if (bankFiles.size() > 0)
    {
        loadFromFXBFile (bankFiles[0]);
    }
    return true;
}

void ObxdAudioProcessor::saveBank() {
    saveFXBFile(currentBankFile);
}

bool ObxdAudioProcessor::loadPreset(const File& fxpFile) {
    loadFromFXPFile(fxpFile);
    currentPreset = fxpFile.getFileName();
    currentPresetFile = fxpFile;
    return true;
}

/// Serialize the current Preset, just like the saveFXPFile function,
/// but keeps the data in memory instead of writing it to a file.
void ObxdAudioProcessor::serializePreset(MemoryBlock& memoryBlock)
{
	juce::MemoryBlock m;
	getCurrentProgramStateInformation(m);
	{
		memoryBlock.reset();
		auto totalLen = sizeof (fxProgramSet) + m.getSize() - 8;
		memoryBlock.setSize (totalLen, true);

		auto set = static_cast<fxProgramSet*>(memoryBlock.getData());
		set->chunkMagic = fxbName ("CcnK");
		set->byteSize = 0;
		set->fxMagic = fxbName ("FPCh");
		set->version = fxbSwap (fxbVersionNum);
		set->fxID = fxbName ("Obxd");
		set->fxVersion = fxbSwap (fxbVersionNum);
		set->numPrograms = fxbSwap (getNumPrograms());
		programs.currentProgramPtr->name.copyToUTF8(set->name, 28);
		set->chunkSize = fxbSwap (static_cast<int32>(m.getSize()));

		m.copyTo (set->chunk, 0, m.getSize());
	}
}

bool ObxdAudioProcessor::saveFXPFile(const File& fxpFile){
    //auto xml = std::unique_ptr<juce::XmlElement>(new juce::XmlElement(""));
    juce::MemoryBlock m, memoryBlock;
    getCurrentProgramStateInformation(m);
    {
        memoryBlock.reset();
        auto totalLen = sizeof (fxProgramSet) + m.getSize() - 8;
        memoryBlock.setSize (totalLen, true);

        auto set = static_cast<fxProgramSet*>(memoryBlock.getData());
        set->chunkMagic = fxbName ("CcnK");
        set->byteSize = 0;
        set->fxMagic = fxbName ("FPCh");
        set->version = fxbSwap (fxbVersionNum);
        set->fxID = fxbName ("Obxd");
        set->fxVersion = fxbSwap (fxbVersionNum);
        set->numPrograms = fxbSwap (getNumPrograms());
        programs.currentProgramPtr->name.copyToUTF8(set->name, 28);
        set->chunkSize = fxbSwap (static_cast<int32>(m.getSize()));

        m.copyTo (set->chunk, 0, m.getSize());
        
        fxpFile.replaceWithData(memoryBlock.getData(), memoryBlock.getSize());
    }
    return true;
}

bool ObxdAudioProcessor::savePreset(const File& fxpFile) {
    saveFXPFile(fxpFile);
    currentPreset = fxpFile.getFileName();
    currentPresetFile = fxpFile;
    return true;
}

void ObxdAudioProcessor::changePresetName(const String &name){
    programs.currentProgramPtr->name = name;
    //savePreset();
    //saveBank();
}

void ObxdAudioProcessor::deletePreset(){
    programs.currentProgramPtr->setDefaultValues();
    programs.currentProgramPtr->name = "Default";
    sendChangeMessage();
    //saveBank();
}

void ObxdAudioProcessor::newPreset(const String &name) {
    for (int i = 0; i < PROGRAMCOUNT; ++i)
    {
        if (programs.programs[i].name == "Default"){
            setCurrentProgram(i);
            break;
        }
    }
    //savePreset();
    //saveBank();
}

void ObxdAudioProcessor::savePreset() {
    savePreset(currentPresetFile);
    
}

bool ObxdAudioProcessor::saveBank(const File& fxbFile){
    saveFXBFile(fxbFile);
    currentBankFile = fxbFile;
    return true;
}

bool ObxdAudioProcessor::saveFXBFile(const File& fxbFile) {
    //auto xml = std::unique_ptr<juce::XmlElement>(new juce::XmlElement(""));
    juce::MemoryBlock m, memoryBlock;
    getStateInformation(m);

    {
        memoryBlock.reset();
        auto totalLen = sizeof (fxChunkSet) + m.getSize() - 8;
        memoryBlock.setSize (totalLen, true);

        auto set = static_cast<fxChunkSet*>( memoryBlock.getData());
        set->chunkMagic = fxbName ("CcnK");
        set->byteSize = 0;
        set->fxMagic = fxbName ("FBCh");
        set->version = fxbSwap (fxbVersionNum);
        set->fxID = fxbName ("Obxd");
        set->fxVersion = fxbSwap (fxbVersionNum);
        set->numPrograms = fxbSwap (getNumPrograms());
        set->chunkSize = fxbSwap (static_cast<int32>(m.getSize()));

        m.copyTo (set->chunk, 0, m.getSize());
        fxbFile.replaceWithData(memoryBlock.getData(), memoryBlock.getSize());
    }
    
    
    return true;
}

bool ObxdAudioProcessor::loadFromFXPFile(const File& fxpFile)
{
	MemoryBlock mb;
	if (! fxpFile.loadFileAsData(mb))
		return false;
	
	if (!loadFromMemoryBlock(mb))
		return false;

	currentPreset = fxpFile.getFileName();
	currentPresetFile = fxpFile;
	updateHostDisplay();
	
	return true;
}

bool ObxdAudioProcessor::loadFromFXBFile(const File& fxbFile)
{
	MemoryBlock mb;
	if (! fxbFile.loadFileAsData(mb))
		return false;
	
	if (!loadFromMemoryBlock(mb))
		return false;
	
	currentBank = fxbFile.getFileName();
	currentBankFile = fxbFile;
	updateHostDisplay();
	
	return true;
}

bool ObxdAudioProcessor::isMemoryBlockAPreset(const MemoryBlock& mb)
{
    const void* const data = mb.getData();
    const size_t dataSize = mb.getSize();

    if (dataSize < 28)
        return false;

    const fxSet* const set = (const fxSet*)data;

    if ((!compareMagic(set->chunkMagic, "CcnK")) || fxbSwap(set->version) > fxbVersionNum)
        return false;
    return true;
}

bool ObxdAudioProcessor::loadFromMemoryBlock(MemoryBlock& mb)
{
	const void* const data = mb.getData();
	const size_t dataSize = mb.getSize();

	if (dataSize < 28)
		return false;

	const fxSet* const set = (const fxSet*) data;

	if ((! compareMagic (set->chunkMagic, "CcnK")) || fxbSwap (set->version) > fxbVersionNum)
		return false;

	if (compareMagic (set->fxMagic, "FxBk"))
	{
		// bank of programs
		if (fxbSwap (set->numPrograms) >= 0)
		{
			const int oldProg = getCurrentProgram();
			const int numParams = fxbSwap (((const fxProgram*) (set->programs))->numParams);
			const int progLen = (int) sizeof (fxProgram) + (numParams - 1) * (int) sizeof (float);

			for (int i = 0; i < fxbSwap (set->numPrograms); ++i)
			{
				if (i != oldProg)
				{
					const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + i * progLen);
					if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
						return false;

					if (fxbSwap (set->numPrograms) > 0)
						setCurrentProgram (i);

					if (! restoreProgramSettings (prog))
						return false;
				}
			}

			if (fxbSwap (set->numPrograms) > 0)
				setCurrentProgram (oldProg);

			const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + oldProg * progLen);
			if (((const char*) prog) - ((const char*) set) >= (ssize_t) dataSize)
				return false;

			if (! restoreProgramSettings (prog))
				return false;
		}
	}
	else if (compareMagic (set->fxMagic, "FxCk"))
	{
		// single program
		const fxProgram* const prog = (const fxProgram*) data;

		if (! compareMagic (prog->chunkMagic, "CcnK"))
			return false;

		changeProgramName (getCurrentProgram(), prog->prgName);

		for (int i = 0; i < fxbSwap (prog->numParams); ++i)
			setEngineParameterValue (i, fxbSwapFloat (prog->params[i]));
	}
	else if (compareMagic (set->fxMagic, "FBCh"))
	{
		// non-preset chunk
		const fxChunkSet* const cset = (const fxChunkSet*) data;

		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxChunkSet) - 8 > (size_t) dataSize)
			return false;

		setStateInformation(cset->chunk, fxbSwap (cset->chunkSize));
        setCurrentProgram(0); // Set to first preset position
	}
	else if (compareMagic (set->fxMagic, "FPCh"))
	{
		// preset chunk
		const fxProgramSet* const cset = (const fxProgramSet*) data;

		if ((size_t) fxbSwap (cset->chunkSize) + sizeof (fxProgramSet) - 8 > (size_t) dataSize)
			return false;

		setCurrentProgramStateInformation(cset->chunk, fxbSwap (cset->chunkSize));

		changeProgramName (getCurrentProgram(), cset->name);
	}
	else
	{
		return false;
	}

	return true;
}

bool ObxdAudioProcessor::restoreProgramSettings(const fxProgram* const prog)
{
	if (compareMagic (prog->chunkMagic, "CcnK")
		&& compareMagic (prog->fxMagic, "FxCk"))
	{
		changeProgramName (getCurrentProgram(), prog->prgName);

		for (int i = 0; i < fxbSwap (prog->numParams); ++i)
			setEngineParameterValue (i, fxbSwapFloat (prog->params[i]));

		return true;
	}

	return false;
}

//==============================================================================
void ObxdAudioProcessor::scanAndUpdateBanks()
{
	bankFiles.clear();

	DirectoryIterator it (getBanksFolder(), false, "*.fxb", File::findFiles);
	
    while (it.next())
	{
		bankFiles.addUsingDefaultSort (it.getFile());
        DBG("Scan Banks: " << it.getFile().getFullPathName());
	}
}

void ObxdAudioProcessor::scanAndUpdateSkins()
{
    skinFiles.clearQuick();
    DirectoryIterator it (getSkinFolder(), false, "*", File::findDirectories);
    
    while (it.next())
    {
        skinFiles.addUsingDefaultSort (it.getFile());
    }
    
}

const Array<File>& ObxdAudioProcessor::getBankFiles() const
{
	return bankFiles;
}

const Array<File>& ObxdAudioProcessor::getSkinFiles() const
{
    return skinFiles;
}

File ObxdAudioProcessor::getCurrentBankFile() const
{
	return getBanksFolder().getChildFile(currentBank);
}

//==============================================================================
File ObxdAudioProcessor::getDocumentFolder() const
{
	File folder = File::getSpecialLocation(File::userDocumentsDirectory).getChildFile("discoDSP").getChildFile("OB-Xd");
/*
    if (! folder.exists())
    {
        NativeMessageBox::showMessageBox(AlertWindow::WarningIcon, "Error", "Documents > discoDSP > OB-Xd folder not found.");
    }
 */
	if (folder.isSymbolicLink())
		folder = folder.getLinkedTarget();
	return folder;
}

File ObxdAudioProcessor::getSkinFolder() const
{
	return getDocumentFolder().getChildFile("Themes");
}

File ObxdAudioProcessor::getBanksFolder() const
{
	return getDocumentFolder().getChildFile("Banks");
}

File ObxdAudioProcessor::getMidiFolder() const
{
    return getDocumentFolder().getChildFile("MIDI");
}


File ObxdAudioProcessor::getPresetsFolder() const
{
    return getDocumentFolder().getChildFile("Presets");
}

File ObxdAudioProcessor::getCurrentSkinFolder() const
{
    DBG(" SKIN : " << currentSkin);
	return getSkinFolder().getChildFile(currentSkin);
}

void ObxdAudioProcessor::setCurrentSkinFolder(const String& folderName)
{
	currentSkin = folderName;

	config->setValue("skin", folderName);
	config->setNeedsToBeSaved(true);
}

void ObxdAudioProcessor::setGuiSize(const int gui_size) {
    this->gui_size = gui_size;
    config->setValue("gui_size", gui_size);
    config->setNeedsToBeSaved(true);
}

Tooltip ObxdAudioProcessor::getTooltipBehavior() const
{
    return tooltipBehavior;
}

void ObxdAudioProcessor::setTooltipBehavior(const Tooltip tooltip)
{
    this->tooltipBehavior = tooltip;
    config->setValue("tooltip", static_cast<int>(tooltip));
    config->setNeedsToBeSaved(true);
}

//==============================================================================
String ObxdAudioProcessor::getEngineParameterId (size_t index)
{
    switch (index)
	{
        case SELF_OSC_PUSH:      return "SelfOscPush";
        case ENV_PITCH_BOTH:     return "EnvPitchBoth";
        case FENV_INVERT:        return "FenvInvert";
		case PW_OSC2_OFS:        return "PwOfs";
        case LEVEL_DIF:          return "LevelDif";
        case PW_ENV_BOTH:        return "PwEnvBoth";
		case PW_ENV:             return "PwEnv";
	    case LFO_SYNC:           return "LfoSync";
        case ECONOMY_MODE:       return "EconomyMode";
	    case UNLEARN:            return "MidiUnlearn";
        case MIDILEARN:          return "MidiLearn";
	    case VAMPENV:            return "VAmpFactor";
        case VFLTENV:            return "VFltFactor";
	    case ASPLAYEDALLOCATION: return "AsPlayedAllocation";
	    case BENDLFORATE:        return "VibratoRate";
	    case FOURPOLE:           return "FourPole";
	    case LEGATOMODE:         return "LegatoMode";
	    case ENVPITCH:           return "EnvelopeToPitch";
	    case OSCQuantize:        return "PitchQuant";
        case VOICE_COUNT:        return "VoiceCount";
	    case BANDPASS:           return "BandpassBlend";
	    case FILTER_WARM:        return "Filter_Warm";
	    case BENDRANGE:          return "BendRange";
        case BENDOSC2:           return "BendOsc2Only";
        case OCTAVE:             return "Octave";
        case TUNE:               return "Tune";
        case BRIGHTNESS:         return "Brightness";
        case NOISEMIX:           return "NoiseMix";
        case OSC1MIX:            return "Osc1Mix";
        case OSC2MIX:            return "Osc2Mix";
        case MULTIMODE:          return "Multimode";
        case LFOSHWAVE:          return "LfoSampleHoldWave";
        case LFOSINWAVE:         return "LfoSineWave";
        case LFOSQUAREWAVE:      return "LfoSquareWave";
        case LFO1AMT:            return "LfoAmount1";
        case LFO2AMT:            return "LfoAmount2";
        case LFOFILTER:          return "LfoFilter";
        case LFOOSC1:            return "LfoOsc1";
        case LFOOSC2:            return "LfoOsc2";
        case LFOFREQ:            return "LfoFrequency";
        case LFOPW1:             return "LfoPw1";
        case LFOPW2:             return "LfoPw2";
        case PORTADER:           return "PortamentoDetune";
        case FILTERDER:          return "FilterDetune";
        case ENVDER:             return "EnvelopeDetune";
        case PAN1:               return "Pan1";
        case PAN2:               return "Pan2";
        case PAN3:               return "Pan3";
        case PAN4:               return "Pan4";
        case PAN5:               return "Pan5";
        case PAN6:               return "Pan6";
        case PAN7:               return "Pan7";
        case PAN8:               return "Pan8";
        case XMOD:               return "Xmod";
        case OSC2HS:             return "Osc2HardSync";
        case OSC1P:              return "Osc1Pitch";
        case OSC2P:              return "Osc2Pitch";
        case PORTAMENTO:         return "Portamento";
        case UNISON:             return "Unison";
        case FLT_KF:             return "FilterKeyFollow";
        case PW:                 return "PulseWidth";
        case OSC2Saw:            return "Osc2Saw";
        case OSC1Saw:            return "Osc1Saw";
        case OSC1Pul:            return "Osc1Pulse";
        case OSC2Pul:            return "Osc2Pulse";
        case VOLUME:             return "Volume";
        case UDET:               return "VoiceDetune";
        case OSC2_DET:           return "Oscillator2detune";
        case CUTOFF:             return "Cutoff";
        case RESONANCE:          return "Resonance";
        case ENVELOPE_AMT:       return "FilterEnvAmount";
        case LATK:               return "Attack";
        case LDEC:               return "Decay";
        case LSUS:               return "Sustain";
        case LREL:               return "Release";
        case FATK:               return "FilterAttack";
        case FDEC:               return "FilterDecay";
        case FSUS:               return "FilterSustain";
        case FREL:               return "FilterRelease";
            
        default:
            break;
    }
    
    return "Undefined";
}

String ObxdAudioProcessor::getTrueParameterValueFromNormalizedRange(size_t index, float value)
{
    switch (index)
    {
    // case SELF_OSC_PUSH:      return "SelfOscPush";
    // case ENV_PITCH_BOTH:     return "EnvPitchBoth";
    // case FENV_INVERT:        return "FenvInvert";
    // case PW_OSC2_OFS:        return "PwOfs";
    // case LEVEL_DIF:          return "LevelDif";
    // case PW_ENV_BOTH:        return "PwEnvBoth";
    // case PW_ENV:             return "PwEnv";
    // case LFO_SYNC:           return "LfoSync";
    // case ECONOMY_MODE:       return "EconomyMode";
    // case UNLEARN:            return "MidiUnlearn";
    // case MIDILEARN:          return "MidiLearn";
    // case VAMPENV:            return "VAmpFactor";
    // case VFLTENV:            return "VFltFactor";
    // case ASPLAYEDALLOCATION: return "AsPlayedAllocation";
    case BENDLFORATE:        return String{ logsc(value, 3, 10), 2 } + " Hz";
    // case FOURPOLE:           return "FourPole";
    // case LEGATOMODE:         return "LegatoMode";
    // case ENVPITCH:           return "EnvelopeToPitch";
    // case OSCQuantize:        return "PitchQuant";
    // case VOICE_COUNT:        return "VoiceCount";
    // case BANDPASS:           return "BandpassBlend";
    // case FILTER_WARM:        return "Filter_Warm";
    // case BENDRANGE:          return "BendRange";
    // case BENDOSC2:           return "BendOsc2Only";
    case OCTAVE:             return String{ (roundToInt(value * 4) - 2) * 12.f, 0 } + " Semitones";
    case TUNE:               return String{ value * 200 - 100, 1 } + " Cents";
    // case BRIGHTNESS:         return "Brightness";
    case NOISEMIX: {
        const auto decibels = Decibels::gainToDecibels(logsc(value, 0, 1, 35));
        if (decibels < -80) return "-Inf";
        return String{ decibels, 2 } + " dB";
    }
    case OSC1MIX:            
    case OSC2MIX: {
        const auto decibels = Decibels::gainToDecibels(value);
        if (decibels < -80) return "-Inf";
        return String{ decibels, 2 } + " dB";
    }
    // case MULTIMODE:          return "Multimode";
    // case LFOSHWAVE:          return "LfoSampleHoldWave";
    // case LFOSINWAVE:         return "LfoSineWave";
    // case LFOSQUAREWAVE:      return "LfoSquareWave";
    // case LFO1AMT:            return "LfoAmount1";
    // case LFO2AMT:            return "LfoAmount2";
    // case LFOFILTER:          return "LfoFilter";
    // case LFOOSC1:            return "LfoOsc1";
    // case LFOOSC2:            return "LfoOsc2";
    case LFOFREQ:            return String{ logsc(value, 0, 50, 120), 2 } + " Hz";
    // case LFOPW1:             return "LfoPw1";
    // case LFOPW2:             return "LfoPw2";
    // case PORTADER:           return "PortamentoDetune";
    // case FILTERDER:          return "FilterDetune";
    // case ENVDER:             return "EnvelopeDetune";
    case PAN1:               
    case PAN2:               
    case PAN3:               
    case PAN4:               
    case PAN5:               
    case PAN6:               
    case PAN7:               
    case PAN8: {
		const auto pan = value - 0.5f;
        if (pan < 0.f) return String{ pan, 2 } + " (Left)";
        if (pan > 0.f) return String{ pan, 2 } + " (Right)";
        return String{ pan, 2 } + " (Center)";
    }
    // case XMOD:               return "Xmod";
    // case OSC2HS:             return "Osc2HardSync";
    case OSC1P:              return String{ (float(value * 4) - 2) * 12.f, 1 } + " Semitones";
    case OSC2P:              return String{ (float(value * 4) - 2) * 12.f, 1 } + " Semitones";
    // case PORTAMENTO:         return "Portamento";
    // case UNISON:             return "Unison";
    // case FLT_KF:             return "FilterKeyFollow";
    // case PW:                 return "PulseWidth";
    // case OSC2Saw:            return "Osc2Saw";
    // case OSC1Saw:            return "Osc1Saw";
    // case OSC1Pul:            return "Osc1Pulse";
    // case OSC2Pul:            return "Osc2Pulse";
    //case VOLUME:             return String{ Decibels::gainToDecibels(linsc(value, 0, 0.30)), 2 };
    // case UDET:               return "VoiceDetune";
    // case OSC2_DET:           return "Oscillator2detune";
    // case CUTOFF:             return "Cutoff";
    // case RESONANCE:          return "Resonance";
    // case ENVELOPE_AMT:       return "FilterEnvAmount";
    // case LATK:               return String{ logsc(value, 4, 60000, 900) / 1000.f, 2};
    // case LDEC:               return String{ logsc(value, 4, 60000, 900) / 1000.f, 2};
    // case LSUS:               return String{ value, 2};
    // case LREL:               return String{ logsc(value, 8, 60000, 900) / 1000.f, 2};
    // case FATK:               return String{ logsc(value, 1, 60000, 900) / 1000.f, 2};
    // case FDEC:               return String{ logsc(value, 1, 60000, 900) / 1000.f, 2};
    // case FSUS:               return String{ value, 2};
    // case FREL:               return String{ logsc(value, 1, 60000, 900) / 1000.f, 2 };

    default:
        break;
    }

    return String{ static_cast<int>(jmap(value, 0.f, 127.f)) };
}

int ObxdAudioProcessor::getParameterIndexFromId (String paramId)
{
    for (size_t i = 0; i < PARAM_COUNT; ++i)
    {
        if (paramId.compare (getEngineParameterId (i)) == 0)
        {
            return int (i);
        }
    }
    
    return -1;
}

void ObxdAudioProcessor::setEngineParameterValue (int index, float newValue, bool notifyToHost)
{
    if (! midiControlledParamSet || index == MIDILEARN || index == UNLEARN)
    {
        lastUsedParameter = index;
    }
    
    programs.currentProgramPtr->values[index] = newValue;
    
    if (notifyToHost){
        apvtState.getParameter(getEngineParameterId(index))->setValueNotifyingHost(newValue);
    } else {
        apvtState.getParameter(getEngineParameterId(index))->setValue(newValue);
    }
    
    //DBG("Set Value Parameter: " << getEngineParameterId(index) << " Val: " << newValue);
    switch (index)
    {
        case SELF_OSC_PUSH:
            synth.processSelfOscPush (newValue);
            break;
        case PW_ENV_BOTH:
            synth.processPwEnvBoth (newValue);
            break;
        case PW_OSC2_OFS:
            synth.processPwOfs (newValue);
            break;
        case ENV_PITCH_BOTH:
            synth.processPitchModBoth (newValue);
            break;
        case FENV_INVERT:
            synth.processInvertFenv (newValue);
            break;
        case LEVEL_DIF:
            synth.processLoudnessDetune (newValue);
            break;
        case PW_ENV:
            synth.processPwEnv (newValue);
            break;
        case LFO_SYNC:
            synth.procLfoSync (newValue);
            break;
        case ECONOMY_MODE:
            synth.procEconomyMode (newValue);
            break;
        case VAMPENV:
            synth.procAmpVelocityAmount (newValue);
            break;
        case VFLTENV:
            synth.procFltVelocityAmount (newValue);
            break;
        case ASPLAYEDALLOCATION:
            synth.procAsPlayedAlloc (newValue);
            break;
        case BENDLFORATE:
            synth.procModWheelFrequency (newValue);
            break;
        case FOURPOLE:
            synth.processFourPole (newValue);
            break;
        case LEGATOMODE:
            synth.processLegatoMode (newValue);
            break;
        case ENVPITCH:
            synth.processEnvelopeToPitch (newValue);
            break;
        case OSCQuantize:
            synth.processPitchQuantization (newValue);
            break;
        case VOICE_COUNT:
            synth.setVoiceCount (newValue);
            break;
        case BANDPASS:
            synth.processBandpassSw (newValue);
            break;
        case FILTER_WARM:
            synth.processOversampling (newValue);
            break;
        case BENDOSC2:
            synth.procPitchWheelOsc2Only (newValue);
            break;
        case BENDRANGE:
            synth.procPitchWheelAmount (newValue);
            break;
        case NOISEMIX:
            synth.processNoiseMix (newValue);
            break;
        case OCTAVE:
            synth.processOctave (newValue);
            break;
        case TUNE:
            synth.processTune (newValue);
            break;
        case BRIGHTNESS:
            synth.processBrightness (newValue);
            break;
        case MULTIMODE:
            synth.processMultimode (newValue);
            break;
        case LFOFREQ:
            synth.processLfoFrequency (newValue);
            break;
        case LFO1AMT:
            synth.processLfoAmt1 (newValue);
            break;
        case LFO2AMT:
            synth.processLfoAmt2 (newValue);
            break;
        case LFOSINWAVE:
            synth.processLfoSine (newValue);
            break;
        case LFOSQUAREWAVE:
            synth.processLfoSquare (newValue);
            break;
        case LFOSHWAVE:
            synth.processLfoSH (newValue);
            break;
        case LFOFILTER:
            synth.processLfoFilter (newValue);
            break;
        case LFOOSC1:
            synth.processLfoOsc1 (newValue);
            break;
        case LFOOSC2:
            synth.processLfoOsc2 (newValue);
            break;
        case LFOPW1:
            synth.processLfoPw1 (newValue);
            break;
        case LFOPW2:
            synth.processLfoPw2 (newValue);
            break;
        case PORTADER:
            synth.processPortamentoDetune (newValue);
            break;
        case FILTERDER:
            synth.processFilterDetune (newValue);
            break;
        case ENVDER:
            synth.processEnvelopeDetune (newValue);
            break;
        case XMOD:
            synth.processOsc2Xmod (newValue);
            break;
        case OSC2HS:
            synth.processOsc2HardSync (newValue);
            break;
        case OSC2P:
            synth.processOsc2Pitch (newValue);
            break;
        case OSC1P:
            synth.processOsc1Pitch (newValue);
            break;
        case PORTAMENTO:
            synth.processPortamento (newValue);
            break;
        case UNISON:
            synth.processUnison (newValue);
            break;
        case FLT_KF:
            synth.processFilterKeyFollow (newValue);
            break;
        case OSC1MIX:
            synth.processOsc1Mix (newValue);
            break;
        case OSC2MIX:
            synth.processOsc2Mix (newValue);
            break;
        case PW:
            synth.processPulseWidth (newValue);
            break;
        case OSC1Saw:
            synth.processOsc1Saw (newValue);
            break;
        case OSC2Saw:
            synth.processOsc2Saw (newValue);
            break;
        case OSC1Pul:
            synth.processOsc1Pulse (newValue);
            break;
        case OSC2Pul:
            synth.processOsc2Pulse (newValue);
            break;
        case VOLUME:
            synth.processVolume (newValue);
            break;
        case UDET:
            synth.processDetune (newValue);
            break;
        case OSC2_DET:
            synth.processOsc2Det (newValue);
            break;
        case CUTOFF:
            synth.processCutoff (newValue);
            break;
        case RESONANCE:
            synth.processResonance (newValue);
            break;
        case ENVELOPE_AMT:
            synth.processFilterEnvelopeAmt (newValue);
            break;
        case LATK:
            synth.processLoudnessEnvelopeAttack (newValue);
            break;
        case LDEC:
            synth.processLoudnessEnvelopeDecay (newValue);
            break;
        case LSUS:
            synth.processLoudnessEnvelopeSustain (newValue);
            break;
        case LREL:
            synth.processLoudnessEnvelopeRelease (newValue);
            break;
        case FATK:
            synth.processFilterEnvelopeAttack (newValue);
            break;
        case FDEC:
            synth.processFilterEnvelopeDecay (newValue);
            break;
        case FSUS:
            synth.processFilterEnvelopeSustain (newValue);
            break;
        case FREL:
            synth.processFilterEnvelopeRelease (newValue);
            break;
        case PAN1:
            synth.processPan (newValue,1);
            break;
        case PAN2:
            synth.processPan (newValue,2);
            break;
        case PAN3:
            synth.processPan (newValue,3);
            break;
        case PAN4:
            synth.processPan (newValue,4);
            break;
        case PAN5:
            synth.processPan (newValue,5);
            break;
        case PAN6:
            synth.processPan (newValue,6);
            break;
        case PAN7:
            synth.processPan (newValue,7);
            break;
        case PAN8:
            synth.processPan (newValue,8);
            break;
    }
    
    //DIRTY HACK
    //This should be checked to avoid stalling on gui update
    //It is needed because some hosts do  wierd stuff
    if (isHostAutomatedChange)
        sendChangeMessage();
}

//==============================================================================
void ObxdAudioProcessor::parameterChanged (const String& parameter, float newValue)
{
    int index = getParameterIndexFromId (parameter);
    
    if ( isPositiveAndBelow (index, PARAM_COUNT) )
    {
        isHostAutomatedChange = false;
        setEngineParameterValue (index, newValue);
        isHostAutomatedChange = true;
    }
}

AudioProcessorValueTreeState& ObxdAudioProcessor::getPluginState()
{
    return apvtState;
}

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



void ObxdAudioProcessor::initMidi(){
    //Documents > Obxd > MIDI > Default.xml
    File default_file = getMidiFolder().getChildFile("Default.xml");
    if (!default_file.exists()){
        bindings.saveFile(default_file);
    }
    
    File midi_config_file = getMidiFolder().getChildFile("Config.xml");
    XmlDocument xmlDoc (midi_config_file);
    std::unique_ptr<XmlElement> ele_file = xmlDoc.getDocumentElementIfTagMatches("File");

    if (ele_file) {
        String file_name = ele_file->getStringAttribute("name");
        // Midi cc loading
        File midi_file = getMidiFolder().getChildFile(file_name);
        if (bindings.loadFile(midi_file)){
            currentMidiPath = midi_file.getFullPathName();
        } else {
            File midi_file = getMidiFolder().getChildFile("Default.xml");
            if (bindings.loadFile(midi_file)){
                currentMidiPath = midi_file.getFullPathName();
            }
        }
    }
}

void ObxdAudioProcessor::updateConfig(){
    File midi_config_file = getMidiFolder().getChildFile("Config.xml");
    XmlDocument xmlDoc (midi_config_file);
    std::unique_ptr<XmlElement> ele_file = xmlDoc.getDocumentElementIfTagMatches("File");
    if (ele_file) {
        File f(currentMidiPath);
        ele_file->setAttribute("name", f.getFileName());
        ele_file->writeTo(midi_config_file.getFullPathName());
    }
}