#include "ofxVamphost.h"

using namespace std;
using namespace Vamp;

int Vamphost::getRT(){
	return rt.msec();
}



Vamphost::Vamphost(){
	loader = PluginLoader::getInstance();
	list=loader->listPlugins();
	for (auto p: list) {
		cerr<<p<<endl;
	}
}

int Vamphost::init(int whichplugin,const int &_channels,const int &_rate,const int &_outputNo,const string &_output){
	key = list[whichplugin];
	init(_channels,_rate,_outputNo,_output);
}


int Vamphost::init(const string &soname,const string &id,const int &_channels,const int &_rate,const int &_outputNo,const string &_output){
	key = loader->composePluginKey(soname, id);
	init(_channels,_rate,_outputNo,_output);
}
int Vamphost::init(const int &_channels,const int &_rate,const int &_outputNo,const string &_output){
	channels =_channels;
	rate=_rate;
	outputNo=_outputNo;
	output=_output;
}
int Vamphost::init(int whichplugin){
	key = list[whichplugin];
	init();
}
int Vamphost::init(){
	//stuff that only happens once
	

	features[0.0f]=0;

	
	
	plugin = loader->loadPlugin(key, rate, PluginLoader::ADAPT_ALL_SAFE);
	if (!plugin) {
		cerr << ": ERROR: Failed to load plugin \"" << key<< "\"" << endl;
		return -1;
	}

	cerr << "Running plugin: \"" << plugin->getIdentifier() << "\"..." << endl;

	blockSize = plugin->getPreferredBlockSize();
	stepSize = plugin->getPreferredStepSize();

	if (blockSize == 0) {
		blockSize = 1024;
	}
	if (stepSize == 0) {
		if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
			stepSize = blockSize/2;
		} else {
			stepSize = blockSize;
		}
	}
	else if (stepSize > blockSize) {
		cerr << "WARNING: stepSize " << stepSize << " > blockSize " << blockSize << ", resetting blockSize to ";
		if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
			blockSize = stepSize * 2;
		} else {
			blockSize = stepSize;
		}
		cerr << blockSize << endl;
	}
	overlapSize = blockSize - stepSize;
	currentStep = 0;
	finalStepsRemaining = max(1, (blockSize / stepSize) - 1); // at end of file, this many part-silent frames needed after we hit EOF

	plugbuf = new float*[channels];
	for (int c = 0; c < channels; ++c) plugbuf[c] = new float[blockSize + 2];

	cerr << "Using block size = " << blockSize << ", step size = "
	      << stepSize << endl;

	// The channel queries here are for informational purposes only --
	// a PluginChannelAdapter is being used automatically behind the
	// scenes, and it will take case of any channel mismatch

	int minch = plugin->getMinChannelCount();
	int maxch = plugin->getMaxChannelCount();
	cerr << "Plugin accepts " << minch << " -> " << maxch << " channel(s)" << endl;
	cerr << "Sound file has " << channels << " (will mix/augment if necessary)" << endl;

	Plugin::OutputList outputs = plugin->getOutputDescriptors();
	Plugin::OutputDescriptor od;

	int returnValue = 1;
	int prog = 0;

	RealTime rt;
	PluginWrapper *wrapper = 0;
	RealTime adjustment = RealTime::zeroTime;

	if (outputs.empty()) {
		cerr << "ERROR: Plugin has no outputs!" << endl;
		return -1;
	}

	if (outputNo < 0) {
		for (size_t oi = 0; oi < outputs.size(); ++oi) {
			if (outputs[oi].identifier == output) {
				outputNo = oi;
				break;
			}
		}
		if (outputNo < 0) {
			cerr << "ERROR: Non-existent output \"" << output << "\" requested" << endl;
			return -1;
		}
	}
	else {
		if (int(outputs.size()) <= outputNo) {
			cerr << "ERROR: Output " << outputNo << " requested, but plugin has only " << outputs.size() << " output(s)" << endl;
			return -1;
		}
	}
	od = outputs[outputNo];
	cerr << "Output is: \"" << od.identifier << "\"" << endl;

	if (!plugin->initialise(channels, stepSize, blockSize)) {
		cerr << "ERROR: Plugin initialise (channels = " << channels
		<< ", stepSize = " << stepSize << ", blockSize = "
		<< blockSize << ") failed." << endl;
		return -1;
	}

	wrapper = dynamic_cast<PluginWrapper *>(plugin);
	if (wrapper) {
		// See documentation for
		// PluginInputDomainAdapter::getTimestampAdjustment
		PluginInputDomainAdapter *ida =wrapper->getWrapper<PluginInputDomainAdapter>();
		if (ida) adjustment = ida->getTimestampAdjustment();
	}

	//everything is prepared to start consuming data in blocks

	in_block=0;
	blocks_processed=0;
	currentStep=0;

	featureNo=1;


	avg=0.0f;
	num=0;
	numFeat=0;

	return blockSize;
}
void Vamphost::process_frame(float *data,int samples_in_frame){
	//
	//

	//plugbuf[0]=data;
	//
	//

	int sample=0;

	//process the whole frame which may be f>1<f blocks
	//when the frame is finished leave the partial block for the next frame
	while(sample<samples_in_frame) {
		while(sample<samples_in_frame&&in_block<blockSize) {
			for (int i=0;i<channels;i++) {
				plugbuf[i][in_block]=data[sample];
				num++;
				avg+=(data[sample]/num);
			}
			in_block++;
			sample++;
		}
		if (in_block==blockSize) {
			//block is ready to be processed
			//cerr<<plugin->getIdentifier()<<" processed block "<<blocks_processed<<endl;

			//I /think/ that the vamp plugin keeps processing through the plugbuf until it encounters 0s
			rt = RealTime::frame2RealTime(currentStep * stepSize, rate);

			Plugin::FeatureSet feat=plugin->process(plugbuf, rt);

			//if (feat[outputNo].size()>0) cerr<<"BEAT"<<endl;

			for (unsigned int i = 0; i < feat[outputNo].size(); ++i) {
				features[((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001)]=featureNo;
				featureNo++;
				numFeat++;
			}

			//shunt it down
            for (int i=0;i<blockSize-stepSize;i++){
                for (int j=0;j<channels;j++){
                    plugbuf[j][i]=plugbuf[j][i+stepSize];
                }
            }

			in_block-=stepSize;
			currentStep++;
		}
	}
}

void Vamphost::cleanup(){

    //process final block
    while(in_block<blockSize) {
        for (int i=0;i<channels;i++) {
            plugbuf[i][in_block]=0.0f;
        }
        in_block++;
    }

    rt = RealTime::frame2RealTime(currentStep * stepSize, rate);

    Plugin::FeatureSet feat=plugin->process(plugbuf, rt);

    for (unsigned int i = 0; i < feat[outputNo].size(); ++i) {
        features[((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001)]=featureNo;
        featureNo++;
    }

    feat=plugin->getRemainingFeatures();

    for (unsigned int i = 0; i < feat[outputNo].size(); ++i) {
        features[((float)feat[outputNo][i].timestamp.sec)+(((float)feat[outputNo][i].timestamp.nsec)*.000000001)]=featureNo;
        featureNo++;
    }

	cerr<<plugin->getIdentifier()<<" found "<<(features.size()-1)<<" features"<<endl;
	//deal with left over data?
	for (int c = 0; c < channels; ++c) {
		delete[] plugbuf[c];
	}
	delete[] plugbuf;
	delete plugin;
}