#include "rotor.h"




using namespace Rotor;
Node_factory::Node_factory(){
	//for now, statically load prototype map in constructor
	add_type("audio_analysis",new Audio_analysis());
	add_type("divide",new Signal_divide());
	add_type("bang",new Is_new_integer());
	add_type("signal_output",new Signal_output());
	add_type("testcard",new Testcard());
	add_type("video_output",new Video_output());
	add_type("video_input",new Video_input());
}

bool Signal_input::connect(Signal_node* source) {
	if (source->output_type=="signal") {
		connection=(Node*)source;
		return true;
	}
	else return false;
}
bool Image_input::connect(Image_node* source) {
	if (source->output_type=="image") {
		connection=(Node*)source;
		return true;
	}
	else return false;
}
bool Signal_output::render(const float duration, const float framerate,string &xml_out){
	//testing signal routes
	cerr << "Rotor: Signal_output rendering " << duration << " seconds at " << framerate << " frames per second" << endl;
	float step=1.0f/framerate;
	float v=0.0f;
	for (float f=0.0f;f<duration;f+=step) {
		float u=get_output(Time_spec(f,framerate));
		if (!fequal(u,v)) {
			xml_out+=("<signal time='"+ofToString(f)+"'>"+ofToString(u)+"</signal>\n");
			v=u;
		}
	}
	return true;
}

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;
	column=0; //point thumbnail bitmap
	out_sample=0; //sample in whole track
	offset=0x1<<(bits-1); //signed audio
	scale=1.0/offset;
	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&&column<width) {
		//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
			double mean=pow(accum/samples,0.5);
			//if (column==0) {
			//	cerr << "first column total: "<< accum << " in " << samples << " samples, average " << (accum/samples)<<endl;
			//}
			int colheight=height*mean*0.5;
			int hh=height>>1;
			for (int i=0;i<height;i++) {
				data[i*width+column]=abs(i-hh)<colheight?0xff:0x00;
			}
			column++;
			sample=0;
			samples=0;
			accum=0.0;
		}
	}
	return out_sample;
}
string Audio_thumbnailer::print(){
	//base64 encode the image data output it

	stringstream output;
	Poco::Base64Encoder *enc=new Poco::Base64Encoder(output);

	enc->write((char*)data,width*height);
	//tring output;
	/*
	for (int j=0;j<height;j++) {
		for (int i=0;i<width;i++) {
			output+=data[j*width+i]<0x7f?"0":"1";
		}
		output +="\n";
	}
	*/
	enc->close();
	delete enc;
	return output.str();
}
bool Audio_analysis::init(int _channels,int _bits,int _samples, int _rate) {
	//need these to make sense of data
	channels=_channels;
	bits=_bits;
	samples=_samples;

	return analyser.init(soname,id,_channels,_bits,_samples,_rate);

	//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 Audio_analysis::process_frame(uint8_t *data,int samples_in_frame) {
	analyser.process_frame(data,samples_in_frame);
	return 1;
}
void Audio_analysis::cleanup() {
	analyser.cleanup();
	//print_features();
}
void Audio_analysis::print_features(){
	for (auto i: analyser.features) {
		cerr<<i.second<<" "<<i.first<<endl;
	}
}

bool Video_output::render(const float duration, const float framerate,const string &output_filename,const string &audio_filename){

	//
	//setup defaults
	int outW=640;
	int outH=360;
	int bitRate=4000000;
	int frameRate=25;
	AVCodecID codecId=AV_CODEC_ID_MPEG4;
	std::string container ="mov";

    bool usingaudio=audioloader.setup(audio_filename);
    //at the moment it crashes if you render before audio is loaded

    float spct=100.0f/duration;

	if (exporter->setup(outW,outH,bitRate,frameRate,container)) { //codecId,
		if (exporter->record(output_filename)) {

			cerr << "Rotor: Video_output rendering " << duration << " seconds at " << framerate << " fps, audio frame size: " << exporter->get_audio_framesize()<<endl;
			//25fps video and 43.06640625fps audio? hmm
			//how to get the timecodes correct for the interleaved files

			float vstep=1.0f/framerate;
			float v=0.0f;
			float vf=0.0f;
			float af=0.0f;
			while (vf<duration) { //float f=0.0f;f<duration;f+=step) {
				//seems to be that the audio frames have to be a little ahead
				//and the frame->pts comes from video
				while (flessorequal(vf,af)) {
					//insert audio frames until we are ahead of the video
			    	uint16_t* s=audioloader.get_samples(exporter->get_audio_framesize());
			    	exporter->encodeFrame(s);
				    af+=exporter->get_audio_step();
				}
			    Image* i=get_output(Frame_spec(vf,framerate,outW,outH));
			    exporter->encodeFrame(i->RGBdata);
			    vf+=vstep;
			    /*
				if (!exporter->encodeFrame(i->RGBdata)){
				//if (!exporter->encodeFrame(get_output(Frame_spec(f,framerate,outW,outH))->RGBdata,audioloader.get_packet())){
					cerr << "Rotor: video output failed"<<endl;
				 	break;
				}
				else {
					cerr << "Rotor: rendered "<<(f*spct)<<"%"<<endl;
					if (f*spct>99.5){

						cerr<<"stop here"<<endl;
					}
				}
				*/
			}
			exporter->finishRecord();
			cerr << "Rotor: Video_output finished "<< endl;
			return true;
		}
	}

	return false;
}

bool Video_input::load(const string &filename){
	//gstreamer needs absolute paths ALWAYS
    //string uri="file:///home/tim/workspace/rotor/rotord/"+filename;
    Poco::Path path;
	string uri="file://"+path.current()+filename;
	//cerr << "video input: loading "<<uri<<endl;
    if (player->loadMovie(uri)){
        player->play();
        player->setPaused(true);
        player->setFrameByFrame(true);
        player->update();
        cerr<<"Rotor::Video_input loaded "<<filename<<", "<<player->getDuration()<<" seconds "<<", "<<player->getWidth()<<"x"<<player->getHeight()<<endl;
       	image->setup_fromRGB(player->getWidth(),player->getHeight(),(uint8_t*) player->getPixels());
        return true;
    }
    return false;
}
Image* Video_input::get_output(const Frame_spec &frame){
    //wonder about the actual mechanism used by gstreamer
    //have to implment callback when seek is ready?
    //presume gstreamer caches a loaded frame?
    //if (player->isLoaded()){
    //    image.setup(player)

    //}

	//deal with reolution: swscale from avcodec or put scaler in pipeline?
	//can image node point to buffer in gst rather than copying the pixels?

	//to test using fp time to seek: need a short movie with synced audio

	//fix actual duration and audio file
	//trace frame that is being read
	if (player->isLoaded()){
		//player->setPosition(frame.time);
		int wanted=((int) (frame.time*frame.framerate))%(player->getTotalNumFrames()-1);
		player->setFrame(wanted);
		//while (player->getCurrentFrame()!=wanted){
		//	cerr << "seeking to "<<wanted<<" :"<<player->getCurrentFrame()<<endl;
			//player->setFrame(wanted);
			//player->update();
		//	sleep(.001);
		//}
		player->update();
		image->RGBdata=player->getPixels(); //don't really know why this is needed every frame
		//cerr<<"Video_input: retrieving frame "<<((int) (frame.time*frame.framerate))<<endl;
		return image;
	}
    return nullptr;
};