/*
 * Copyright 2012, Gerasim Troeglazov (3dEyes**), 3dEyes@gmail.com.
 * All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <stdio.h>
#include <stdlib.h>
#include <image.h>

#include <Application.h>

#include "VSTHost.h"

static int32 VHostCallback(VSTEffect* effect, int32 opcode, int32 index,
	int32 value, void* ptr, float opt);

//Trim string
static void
TrimString(BString *string) {
	char* str = string->LockBuffer(256);
    uint32 k = 0;
    uint32 i = 0;
    for(i=0; str[i]!='\0';) {
        if (isspace(str[i])) {
            k = i;
            for(uint32 j = i; j < strlen(str) - 1; j++)
                str[j] = str[j + 1];
            str[strlen(str) - 1] = '\0';
            i = k;
        } else
            i++;
    }
    string->UnlockBuffer();
}

//VST Parameter class
VSTParameter::VSTParameter(VSTPlugin* plugin, int index)
{
	fIndex = index;
	fEffect = plugin->Effect();
	fDropList.MakeEmpty();

	char temp[256];
  	//get parameter name
  	temp[0] = 0;
	fEffect->dispatcher(fEffect, VST_GET_PARAM_NAME, index, 0, temp, 0);
	fName.SetTo(temp);
	TrimString(&fName);
	//get parameter label (unit)
	temp[0] = 0;
	fEffect->dispatcher(fEffect, VST_GET_PARAM_UNIT, index, 0, temp, 0);
	fUnit.SetTo(temp);
	ValidateValues(&fUnit);
	//store current value
	float val = fEffect->getParameter(fEffect, index);
	//test for minimum value
	fEffect->setParameter(fEffect, index, 0);
	temp[0] = 0;
	fEffect->dispatcher(fEffect, VST_GET_PARAM_STR, index, 0, temp, 0);
	fMinValue.SetTo(temp);
	ValidateValues(&fMinValue);
	//test for maximum value
	temp[0] = 0;
	fEffect->setParameter(fEffect, index, 1.0);
	fEffect->dispatcher(fEffect, VST_GET_PARAM_STR, index, 0, temp, 0);
	fMaxValue.SetTo(temp);
	ValidateValues(&fMaxValue);
	//test for discrete values
	char test_disp[VST_PARAM_TEST_COUNT][256];
	float test_values[VST_PARAM_TEST_COUNT];
	float delta = 1.0 / (float)VST_PARAM_TEST_COUNT;
	int test_cnt = 0;
	for(int tst_val = 0; tst_val < VST_PARAM_TEST_COUNT; tst_val++) {
		float v = (float)tst_val / (float)VST_PARAM_TEST_COUNT;

		if (tst_val >= VST_PARAM_TEST_COUNT - 1)
			v = 1.0;

		fEffect->setParameter(fEffect, index, v);

		float new_value = fEffect->getParameter(fEffect, index);
		bool valtest = false;
		for(int i = 0; i < test_cnt; i++) {
			if (fabs(test_values[i] - new_value) < delta) {
				valtest = true;
				break;
			}
		}
		if (valtest == false) {
			test_values[test_cnt] = new_value;
			fEffect->dispatcher(fEffect, VST_GET_PARAM_STR, index,
				0, test_disp[test_cnt], 0);
			test_cnt++;
		}
	}

	//restore value
	fEffect->setParameter(fEffect, index, val);

	//detect param type
	if (test_cnt == 2) {
		fType = VST_PARAM_CHECKBOX;

		DropListValue* min_item = new DropListValue();
		min_item->Value = 0.0;
		min_item->Index = 0;
		min_item->Name = fMinValue;
		fDropList.AddItem(min_item);

		DropListValue* max_item = new DropListValue();
		max_item->Value = 1.0;
		max_item->Index = 1;
		max_item->Name = fMaxValue;
		fDropList.AddItem(max_item);
	} else if (test_cnt > 2 && test_cnt < VST_PARAM_TEST_COUNT / 2) {
		fType = VST_PARAM_DROPLIST;

		for(int i = 0; i < test_cnt; i++) {
			DropListValue* item = new DropListValue();
			item->Value = test_values[i];
			item->Index = i;
			item->Name = test_disp[i];
			fDropList.AddItem(item);
		}
	} else {
		fType = VST_PARAM_SLIDER;
	}
	fChanged = 0LL;
}

VSTParameter::~VSTParameter()
{
}

BString*
VSTParameter::ValidateValues(BString* string)
{
	if (string->Length() == 0)
		return string;

	bool isNum = true;

	const char *ptr = string->String();
	for(; *ptr!=0; ptr++) {
		char ch = *ptr;
		if (!((ch >= '0' && ch <= '9') || ch == '.' || ch == '-')) {
			isNum = false;
			break;
		}
	}

	if (isNum) {
		float val = atof(string->String());

		if (val <= -pow(2, 31)) {
			string->SetTo("-∞");
		} else if (val >= pow(2, 31)) {
			string->SetTo("∞");
		} else {
			char temp[256];
			sprintf(temp, "%g", val);
			string->SetTo(temp);
		}
	} else {
		TrimString(string);
		if (*string == "oo" || *string == "inf")
			string->SetTo("∞");
		if (*string == "-oo" || *string == "-inf")
			string->SetTo("-∞");

	}
	return string;
}

int
VSTParameter::ListCount(void)
{
	return fDropList.CountItems();
}

DropListValue*
VSTParameter::ListItemAt(int index)
{
	DropListValue* item = NULL;
	if (index >= 0 && index < fDropList.CountItems())
		item = (DropListValue*)fDropList.ItemAt(index);
	return item;
}


float
VSTParameter::Value()
{
	float value = fEffect->getParameter(fEffect, fIndex);
	if (fType == VST_PARAM_DROPLIST) {
		//scan for near value
		int	min_index = 0;
		float min_delta = 1.0;
		for(int i = 0; i < fDropList.CountItems(); i++) {
			DropListValue* item = (DropListValue*)fDropList.ItemAt(i);
			float delta	= fabs(item->Value - value);
			if (delta <= min_delta) {
				min_delta = delta;
				min_index = i;
			}
		}
		value = min_index;
	}
	fLastValue = value;
	return value;
}

void
VSTParameter::SetValue(float value)
{
	if (value == fLastValue)
		return;

	if (fType == VST_PARAM_DROPLIST) {
		//take value by index
		int index = (int)vstround(value);
		if (index >= 0 && index < fDropList.CountItems()) {
			DropListValue *item = (DropListValue*)fDropList.ItemAt(index);
			value = item->Value;
			fLastValue = index;
		} else {
			return;
		}
	} else {
		fLastValue = value;
	}
	fChanged = system_time();
	fEffect->setParameter(fEffect, fIndex, value);
}

bigtime_t
VSTParameter::LastChangeTime(void)
{
	return fChanged;
}

const char*
VSTParameter::MinimumValue(void)
{
	return fMinValue.String();
}

const char*
VSTParameter::MaximumValue(void)
{
	return fMaxValue.String();
}

const char*
VSTParameter::Unit(void)
{
	return fUnit.String();
}

int
VSTParameter::Index(void)
{
	return fIndex;
}

int
VSTParameter::Type(void)
{
	return fType;
}

const char*
VSTParameter::Name(void)
{
	return fName.String();
}

//VST Plugin class
VSTPlugin::VSTPlugin()
{
	fActive = false;
	fEffect = NULL;
	VSTMainProc = NULL;
	fInputChannels = 0;
	fOutputChannels = 0;
	fSampleRate = 44100.f;
	fBlockSize = 0;
	inputs = NULL;
	outputs = NULL;
	fParameters.MakeEmpty();
}

VSTPlugin::~VSTPlugin()
{
	fParameters.MakeEmpty();
	UnLoadModule();
}

int
VSTPlugin::LoadModule(const char *path)
{
	char effectName[256] = {0};
	char vendorString[256] = {0};
	char productString[256] = {0};

	if (fActive)
		return VST_ERR_ALREADY_LOADED;

	fPath = BPath(path);

	fModule = load_add_on(path);
	if (fModule <= 0)
		return VST_ERR_NOT_LOADED;

	if (get_image_symbol(fModule, "main_plugin", B_SYMBOL_TYPE_TEXT,
			(void**)&VSTMainProc) != B_OK) {
		unload_add_on(fModule);
		return VST_ERR_NO_MAINPROC;
	}

	fEffect = VSTMainProc(VHostCallback);
	if (fEffect==NULL) {
		unload_add_on(fModule);
		return VST_ERR_NOT_LOADED;
	}

	fEffect->dispatcher(fEffect, VST_OPEN, 0, 0, 0, 0);

	fEffect->dispatcher(fEffect, VST_GET_EFFECT_NAME, 0, 0, effectName, 0);
	fEffectName.SetTo(effectName);
	TrimString(&fEffectName);

	fModuleName.SetTo("VST:");
	fModuleName.Append(fPath.Leaf());

	fEffect->dispatcher(fEffect, VST_GET_VENDOR_STR, 0, 0, vendorString, 0);
	fVendorString.SetTo(vendorString);
	TrimString(&fVendorString);

	fEffect->dispatcher(fEffect, VST_GET_PRODUCT_STR, 0, 0, productString, 0);
	fProductString.SetTo(productString);
	TrimString(&fProductString);

	fInputChannels = fEffect->numInputs;
	fOutputChannels = fEffect->numOutputs;

	for(int i=0; i < fEffect->numParams; i++) {
		VSTParameter *param = new VSTParameter(this, i);
		fParameters.AddItem(param);
	}

	fEffect->dispatcher(fEffect, VST_STATE_CHANGED, 0, 1, 0, 0);

	ReAllocBuffers();

	fActive = true;
	return B_OK;
}

int
VSTPlugin::UnLoadModule(void)
{
	if (!fActive || fModule <= 0)
		return VST_ERR_NOT_LOADED;

	fEffect->dispatcher(fEffect, VST_STATE_CHANGED, 0, 0, 0, 0);
	fEffect->dispatcher(fEffect, VST_CLOSE, 0, 0, 0, 0);

	unload_add_on(fModule);

	return B_OK;
}

int
VSTPlugin::Channels(int mode)
{
	switch(mode) {
		case VST_INPUT_CHANNELS:
			return fInputChannels;
		case VST_OUTPUT_CHANNELS:
			return fOutputChannels;
		default:
			return 0;
	}
}

int
VSTPlugin::SetSampleRate(float rate)
{
	fSampleRate = rate;
	fEffect->dispatcher(fEffect, VST_SET_SAMPLE_RATE, 0, 0, 0, rate);
	return B_OK;
}

float
VSTPlugin::SampleRate(void)
{
	return fSampleRate;
}

int
VSTPlugin::SetBlockSize(size_t size)
{
	fBlockSize = size;
	fEffect->dispatcher(fEffect, VST_SET_BLOCK_SIZE, 0, size, 0, 0);
	ReAllocBuffers();
	return B_OK;
}

const char*
VSTPlugin::Path(void)
{
	return fPath.Path();
}

int
VSTPlugin::ReAllocBuffers(void)
{
	if (inputs != NULL) {
		for(int32 i = 0; i < fInputChannels; i++)
			delete inputs[i];
	}

	if (outputs != NULL) {
		for(int32 i = 0; i < fOutputChannels; i++)
			delete outputs[i];
	}

	if (fInputChannels > 0) {
		inputs = new float*[fInputChannels];
		for(int32 i = 0; i < fInputChannels; i++)	{
			inputs[i] = new float[fBlockSize];
			memset(inputs[i], 0, fBlockSize * sizeof(float));
		}
	}

	if (fOutputChannels > 0) {
		outputs = new float*[fOutputChannels];
		for(int32_t i = 0; i < fOutputChannels; i++) {
			outputs[i] = new float[fBlockSize];
			memset (outputs[i], 0, fBlockSize * sizeof(float));
		}
	}
	return B_OK;
}

size_t
VSTPlugin::BlockSize(void)
{
	return fBlockSize;
}

int
VSTPlugin::ParametersCount(void)
{
	return fParameters.CountItems();
}

VSTParameter*
VSTPlugin::Parameter(int index)
{
	VSTParameter* param = NULL;

	if (index >= 0 && index < fParameters.CountItems())
		param = (VSTParameter*)fParameters.ItemAt(index);

	return param;
}

VSTEffect*
VSTPlugin::Effect(void)
{
	return fEffect;
}

const char*
VSTPlugin::EffectName(void)
{
	return fEffectName.String();
}

const char*
VSTPlugin::ModuleName(void)
{
	return fModuleName.String();
}

const char*
VSTPlugin::Vendor(void)
{
	return fVendorString.String();
}

const char*
VSTPlugin::Product(void)
{
	return fProductString.String();
}


void
VSTPlugin::Process(float *buffer, int samples, int channels)
{
	//todo: full channels remapping needed
	float* src = buffer;

	if (channels == fInputChannels) { //channel to channel
		for(int j = 0; j < samples; j++) {
			for(int c = 0; c < fInputChannels; c++)
				inputs[c][j] = *src++;
		}
	} else if ( channels == 1) {	//from mone to multichannel
		for(int j = 0; j < samples; j++, src++) {
			for(int c = 0; c < fInputChannels; c++)
				inputs[c][j] = *src;
		}
	}

	fEffect->processReplacing(fEffect, inputs, outputs, fBlockSize);

	float* dst = buffer;

	if (channels == fOutputChannels) { //channel to channel
		for(int j = 0; j < samples; j++) {
			for(int c = 0; c < fOutputChannels; c++)
				*dst++ = outputs[c][j];
		}
	} else if (channels == 1) {  //from multichannel to mono
		for(int j = 0; j < samples; j++, dst++) {
			float mix = 0;
			for(int c = 0; c < fOutputChannels; c++)
				mix += outputs[c][j];
			*dst = mix / (float)fOutputChannels;
		}
	}
}

static int32
VHostCallback(VSTEffect* effect, int32 opcode, int32 index, int32 value,
	void* ptr, float opt)
{
	intptr_t result = 0;

	switch(opcode)
	{
		case VST_MASTER_PRODUCT:
			if (ptr) {
				strcpy((char*)ptr, "VSTHost Media AddOn");
				result = 1;
			}
			break;
		case VST_MASTER_VERSION :
			result = 2300;
			break;
	}

	return result;
}