#include "nodes_audio_analysis.h"

namespace Rotor{
	bool Audio_thumbnailer::init(int _channels,int _bits,int _samples,int _rate) {
		//base_audio_processor::init(_channels,_bits,_samples);
		channels=_channels;
		bits=_bits;
		samples=_samples;
		samples_per_column=samples/width;
		offset=0x1<<(bits-1); //signed audio
		scale=1.0f/offset;

		out_sample=0; //sample in whole track
		sample=0;
		samples=0;
		accum=0.0;
		return true;
	}
	int Audio_thumbnailer::process_frame(uint8_t *_data,int samples_in_frame){
		//begin by processing remaining samples
		//samples per column could be larger than a frame! (probably is)
		//but all we are doing is averaging
		int bytes=(bits>>3);
		int stride=channels*bytes;
		int in_sample=0;
		while (in_sample<samples_in_frame) {
			//continue the column
			while (sample<samples_per_column&&in_sample<samples_in_frame) {
				//accumulate samples for this column until we run out of samples
				for (int i=0;i<channels;i++) {
					unsigned int this_val=0;
					for (int j=0;j<bytes;j++) {
						this_val+=_data[(in_sample*stride)+(i*bytes)+j]<<(j*8);
					}
					//convert from integer data format - i.e s16p - to audio signal in -1..1 range
					//presume 16 bits for now...
					double val=((double)((int16_t)this_val))*scale;
					accum+=val*val;
					samples++;
				}
				in_sample++;
				sample++;
				out_sample++;
			}
			if (sample==samples_per_column) { //finished a column
				//get root-mean
				//why does valgrind complain here about uninitialised vars
				double mean=pow(accum/samples,0.5f);
				audiodata.push_back(mean);
				sample=0;
				samples=0;
				accum=0.0;
			}
		}
		return out_sample;
	}
	void Audio_thumbnailer::print_vector(xmlIO XML){
		string vdata;
		int i=0;
		for (auto sample: audiodata){
			if (i>0) vdata+=",";
			vdata+=toString(sample);
		}
		XML.addValue("data",vdata);
	}
	bool Vamp_node::init(int _channels,int _bits,int _samples, int _rate) {
		//need these to make sense of data
		channels=_channels;
		bits=_bits;
		samples=_samples;

		features.clear();
		return analyser.init(soname,id,_channels,_bits,_samples,_rate,outputNo,params);


		//attempt to load vamp plugin and prepare to receive frames of data
		//should the audio analysis contain a vamphost or should it inherit?
		//maybe neater to contain it in terms of headers etc

	}
	int Vamp_node::process_frame(uint8_t *data,int samples_in_frame) {
		analyser.process_frame(data,samples_in_frame);
		return 1;
	}
	void Vamp_node::cleanup() {
		analyser.cleanup();
		features=analyser.features;
	}
	string Vamp_node::get_features(){
		string data;
		for (auto i: features) {
			data=data+" ["+toString(i.second.number)+":"+toString(i.first);
			if (i.second.values.size()) {
				data+=" (";
				bool first=true;
				for (auto j: i.second.values) {	
					if (first){
						first=false;
					}
					else data+=",";
					data=data+toString(j);
				}
				data+=") ";
			}	
			data+="]";
		}
		return data;
	}
	bool sortsegments(std::pair<int,float> i,std::pair<int,float> j){
		return (i.second<j.second);
	}
	void Intensity_segmenter::cleanup(){
		//algorithm idea:
		//get average tempo and intensity for each segment and store them
		//scale by the range to get a value from 0.0 to 1.0
		//add tempo and intensity according to a weighting
		//score the results (ie 1st place, 2nd place) to end up with a set of integer numbers

		//for (auto a:analysers) a.second.cleanup(); //WHY NOT WORK - its as if the call is const
		analysers["segmenter"].cleanup();
		analysers["tempo"].cleanup();
		analysers["intensity"].cleanup();
		cerr<<analysers["segmenter"].features.size()<<" segments"<<endl;
		cerr<<analysers["tempo"].features.size()<<" tempo features"<<endl;
		cerr<<analysers["intensity"].features.size()<<" intensity features"<<endl;
		uint32_t i=0;
		float min_tempo=9999999.0f;
		float min_intensity=9999999.0f;
		float max_tempo=0.0f;
		float max_intensity=0.0f;
		vector<float> tempos;
		vector<float> intensities;
		vector<float> times;
		auto g=++analysers["segmenter"].features.begin();
		for (auto f=analysers["segmenter"].features.begin();g!=analysers["segmenter"].features.end();f++,g++,i++){
			cerr<<"segment "<<i<<": "<<f->first<<" to "<<g->first<<endl;
			times.push_back(f->first);
			//integrate tempo and intensity algorithmically
			float tempo=0;
			if (analysers["tempo"].features.size()) {
				float pt=f->first;
				float pv=analysers["tempo"].get_value(f->first);
				for (auto u=analysers["tempo"].features.upper_bound(f->first);u!=analysers["tempo"].features.upper_bound(g->first);u++){
					tempo +=(u->first-pt)*(u->second.values[0]+pv)*0.5f; //area of the slice
					pt=u->first;
					pv=u->second.values[0];
				}
				tempo +=(g->first-pt)*(analysers["tempo"].get_value(g->first)+pv)*0.5f; //area of the last slice
				tempo /=g->first-f->first; //average value;
			}
			if (tempo>max_tempo) max_tempo=tempo;
			if (tempo<min_tempo) min_tempo=tempo;
			tempos.push_back(tempo);
			cerr<<"segment "<<i<<" average tempo: "<<tempo<<endl;

			float intensity=0;
			if (analysers["intensity"].features.size()) {
				float pt=f->first;
				float pv=analysers["intensity"].get_value(f->first);
				for (auto u=analysers["intensity"].features.upper_bound(f->first);u!=analysers["intensity"].features.upper_bound(g->first);u++){
					intensity +=(u->first-pt)*(u->second.values[0]+pv)*0.5f; //area of the slice
					pt=u->first;
					pv=u->second.values[0];
				}
				intensity +=(g->first-pt)*(analysers["intensity"].get_value(g->first)+pv)*0.5f; //area of the last slice
				intensity /=g->first-f->first; //average value;
			}
			if (intensity>max_intensity) max_intensity=intensity;
			if (intensity<min_intensity) min_intensity=intensity;
			intensities.push_back(intensity);
		}
		//make relative scale 0.0-1.0 and save weighted totals
		vector< pair<int,float>> totals;
		for (i=0;i<tempos.size();i++){
			tempos[i]=(tempos[i]-min_tempo)/(max_tempo-min_tempo);
			intensities[i]=(intensities[i]-min_intensity)/(max_intensity-min_intensity);
			totals.push_back(make_pair(i,(tempos[i]*parameters["tempo_weight"]->value)+(intensities[i]*parameters["intensity_weight"]->value)));
		}
		//sort and convert to features
		std::sort(totals.begin(),totals.end(),sortsegments);
		for (i=0;i<totals.size();i++) {
			cerr<<"segment "<<totals[i].first<<" average intensity: "<<totals[i].second<<endl;
		}
		vector<float> bucketoffsets;
		for (auto t:totals) bucketoffsets.push_back(0.0f);
		if (parameters["levels"]->value>0.0f&&parameters["levels"]->value<totals.size()){
			//use bucketoffsets to redistribute into smaller number of buckets
			int numbertoredistribute=totals.size()-((int)parameters["levels"]->value);
			float numberperbin=((float)numbertoredistribute/totals.size());
			float toadd=0.5f;
			int added=0;
			for (int j=0;j<totals.size();j++){
				int numbertoadd=min(numbertoredistribute-added,(int)toadd);
				toadd=(toadd+numberperbin)-numbertoadd;
				added+=numbertoadd;
				bucketoffsets[j]=added;
			}
			if (numbertoredistribute>0) {
				cerr<<"reducing number of levels by "<<numbertoredistribute<<", offsets:"<<endl;
				for (auto o:bucketoffsets) {
					cerr<<o<<":";
				}
				cerr<<endl;
			}
		}
		for (i=0;i<totals.size();i++){
			vampHost::feature f;
			f.values.push_back((float)i-bucketoffsets[i]);
			features[times[totals[i].first]]=f;
		}			
	}
}