//===============================================================
// This is a simple ET to ET transport program
//===============================================================

#include <signal.h>
#include <time.h>
#include <iostream>
#include <string>
using namespace std;

#include <evioETChannel.hxx>
#include <et.h>

#include <evioChannel.hxx>
#include <evioUtil.hxx>
using namespace evio;

#define USE_CODA_RUNOBJECTS 0

#if USE_CODA_RUNOBJECTS
#include <RunObject.hxx>
using namespace codaObject;
#endif // USE_CODA_RUNOBJECTS

bool QUIT = false;
uint32_t Nevents = 0;

string source_name="";
string sink_name="";

et_sys_id source_sys_id;
et_att_id source_att_id;
et_sys_id sink_sys_id;
et_att_id sink_att_id;

uint32_t OUTPUT_BUFFER_SIZE = 150000; // bytes
uint32_t INPUT_BUFFER_SIZE = 150000; // bytes

int ET_STATION_NEVENTS = 100;
bool ET_STATION_CREATE_BLOCKING = true;

evioChannel *input_chan;

#ifndef _DBG_
#define _DBG_ cout<<__FILE__<<":"<<__LINE__<<" "
#define _DBG__ cout<<__FILE__<<":"<<__LINE__<<endl
#endif


void Usage(string end_message="");
void ParseCommandLineArguments(int narg, char *argv[]);
void OpenInputET(string source_name);
void OpenOutputET(string sink_name);

#if USE_CODA_RUNOBJECTS
// CODA object class for interfacing with
// CODA system. This is needed so we can include this
// program as a component in jcedit.
class HDet2et : public RunObject{

public:
	HDet2et(const string& UDL, const string& name, const string& descr, const string &session) :  RunObject(UDL,name,descr) {
		cout << "HDet2et constructor called" << endl;
		handleSetSession(session);
	}

	bool userConfigure(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userDownload(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userPrestart(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userGo(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userPause(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userResume(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userEnd(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	bool userReset(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl; return(true); }
	void exit(const string& s) throw (codaObject::CodaException) { _DBG_<<s<<endl;  }
};
#endif // USE_CODA_RUNOBJECTS


//-----------------
// sigHandler
//-----------------
void sigHandler(int sig)
{
	cout << "SIGINT received ..." << endl;
	QUIT = true;
}

//-----------
// SendDummyEvents
//-----------
void SendDummyEvents(uint32_t N)
{
	for(uint32_t i=0; i<N; i++){
		et_event *pe_out=NULL;
		int status = et_event_new(sink_sys_id, sink_att_id, &pe_out, ET_SLEEP, NULL, 40);
		if(status != ET_OK){
			cerr << "Unable to write new event to output (et_event_new returns "<<status<<")!" << endl;
			continue;
		}
		
		uint32_t ipdata[10];

		ipdata[0] = 0x0000000A; // Number of 32 bit words in evio block, inclusive
		ipdata[1] = 0x00000001; // Block number
		ipdata[2] = 0x00000008; // Length of block header (words)
		ipdata[3] = 0x00000001; // Event Count
		ipdata[4] = 0x00000000; // Reserved 1
		ipdata[5] = 0x00000204; // (1<<10) is Bit Info and indicates "Physics" payload bank type. 0x4 indicates EVIO version 1 
		ipdata[6] = 0x00000000; // Reserved 2
		ipdata[7] = 0xc0da0100; // Magic number
		ipdata[8] = 0x00000001; // EVIO block length
		ipdata[9] = 0xc0021001;
		
		char *pdata_out = NULL;
		et_event_getdata(pe_out, (void**)&pdata_out);
		memcpy(pdata_out, (char*)ipdata, 40);
		status = et_event_put(sink_sys_id, sink_att_id, pe_out);
		cout << "Wrote dummy event to output ET. status=" << status << endl;
	} 
}

//-----------
// main
//-----------
int main(int narg, char *argv[])
{
	// Register signal handler so user can quit with ctl-C
	signal(SIGINT, sigHandler);

	if(narg<=1)Usage();

	// Parse command line arguments
	ParseCommandLineArguments(narg, argv);

	// Open the input ET system
	OpenInputET(source_name);

	// Open the output ET system
	OpenOutputET(sink_name);


#if USE_CODA_RUNOBJECTS
	const char *expid_ptr = getenv("EXPID");
	if(!expid_ptr){
		cout << "EXPID environment variable not set!" << endl;
		exit(-1);
	}
	string expid(expid_ptr);

	const char *session_ptr = getenv("SESSION");
	if(!session_ptr){
		cout << "SESSION environment variable not set!" << endl;
		exit(-1);
	}
	string session(session_ptr);

	string UDL = "rc://multicast/" + expid;

//	cMsg *dataConn = new cMsg(UDL, "hdet2et/data","hdet2et data connection");
//	dataConn->connect();

	// Create CODA RunObject
	HDet2et hdet2et(UDL, "hdet2et", "ET 2 ET bridge", session);
	hdet2et.startProcessing();

#endif // USE_CODA_RUNOBJECTS

	// Allocate memory for event buffer
	//uint32_t *buff = (uint32_t*)malloc(INPUT_BUFFER_SIZE);
	
	//SendDummyEvents(10);

	// Loop over events until user says to quit
	cout << "==============================================" << endl;
	cout << "Starting event transfer. Hit ctl-C to quit ..." << endl;
	while(!QUIT){
		
		// Read event from input ET system
		et_event *pe_in=NULL;
		struct timespec timeout = {0, (uint32_t)5E8};
		int err = et_event_get(source_sys_id, source_att_id, &pe_in, ET_TIMED , &timeout);

		if( err==ET_ERROR_TIMEOUT ){
			// No event available. Do nothing.
		}else if( err == ET_OK && pe_in==NULL){
			cout << "  !!! ET returned no error, but event pointer is NULL!!!" << endl;
			continue;
		}else if( err == ET_OK && pe_in!=NULL){

			// got an event from source
			uint32_t *et_buff=NULL;
			err = et_event_getdata(pe_in, (void**)&et_buff);
			if(et_buff == NULL){
				cerr << " Got event from ET, but pointer to data is NULL!" << endl;
				continue;
			}

			size_t buff_size_bytes = 0;
			et_event_getlength(pe_in, &buff_size_bytes);

			// get event from sink
			et_event *pe_out=NULL;
			int status = et_event_new(sink_sys_id, sink_att_id, &pe_out, ET_SLEEP, NULL, buff_size_bytes);
			if(status != ET_OK){
				cerr << "Unable to write new event to output (et_event_new returns "<<status<<")!" << endl;
				cerr << " buff_size_bytes = " << buff_size_bytes << endl;
				status = et_event_put(source_sys_id, source_att_id, pe_in);
				continue;
			}

			// Copy data directly from source to sink
			char *pdata_out, *pdata_in;
			//et_event_getdata(pe_in, (void**)&pdata_in);
			pdata_in = (char*)et_buff;
			et_event_getdata(pe_out, (void**)&pdata_out);
			memcpy(pdata_out, pdata_in, buff_size_bytes);

			
			// Put output ET event back
			status = et_event_put(sink_sys_id, sink_att_id, pe_out);

			// Put input ET event back
			et_event_put(source_sys_id, source_att_id, pe_in);
			
			Nevents++;
		}
		
		if(Nevents%10000 == 0)cout << " Nevents: " << Nevents << "    \n"; cout.flush();

		// Sleep a minimum amount of time
		//struct timespec sleep_time = {0, 1};
		//nanosleep(&sleep_time, NULL);
	}
	cout << "==============================================" << endl;
	
	// Close connections ET systems
	cout << "Closing connections to ET systems ..." << endl;
	if(source_sys_id) et_close(source_sys_id);
	if(sink_sys_id) et_close(sink_sys_id);
	
	cout << "Done" << endl;
	return 0;
}

//---------------------------------
// ParseCommandLineArguments
//---------------------------------
void ParseCommandLineArguments(int narg, char *argv[])
{
	if(narg !=3) Usage("You must supply exactly 2 arguments!");

	source_name = string(argv[1]);
	sink_name = string(argv[2]);
	
	if(source_name.find("ET:") != 0){
		Usage("Input source name MUST start with \"ET:\"!");
	}

	if(sink_name.find("ET:") != 0){
		Usage("Output sink name MUST start with \"ET:\"!");
	}
}

//---------------------------------
// OpenInputET
//---------------------------------
void OpenInputET(string source_name)
{
	// Split source name into session, station, etc...
	vector<string> fields;
	string str = source_name;
	size_t startpos=0, endpos=0;
	while((endpos = str.find(":", startpos)) != str.npos){
		size_t len = endpos-startpos;
		fields.push_back(len==0 ? "":str.substr(startpos, len));
		startpos = endpos+1;
	}
	if(startpos<str.length()) fields.push_back(str.substr(startpos, str.npos));

	string session = fields.size()>1 ? fields[1]:"";
	string station = fields.size()>2 ? fields[2]:"";
	string host    = fields.size()>3 ? fields[3]:"";
	int port       = fields.size()>4 ? atoi(fields[4].c_str()):ET_SERVER_PORT;

	if(session == "") session = "none";
	if(station == "") station = "ET2ET";
	string fname = session.at(0)=='/' ? session:(string("/tmp/et_sys_") + session);
	
	// Report to user what we're doing
	cout << " Input ET system ==================" << endl;
	if(session.at(0)!='/') cout << "         session: " << session << endl;
	cout << "         station: " << station << endl;
	cout << "     system file: " << fname << endl;
	if(host!=""){
		cout << "            host:\""<<host<<"\"" << endl;
		if(port !=0) cout << "            port: " << port << endl;
	}

	// connect to the ET system
	et_openconfig openconfig;
	et_open_config_init(&openconfig);
	if(host != ""){
		if(host.find("239.")==0){
			cout<<__FILE__<<":"<<__LINE__<<" Configuring input ET for multicast" << endl;
			et_open_config_setcast(openconfig, ET_MULTICAST);
			et_open_config_addmulticast(openconfig, host.c_str());
			et_open_config_sethost(openconfig, ET_HOST_ANYWHERE);
			et_open_config_setport(openconfig, port);
			struct timespec tspec={5,5};
			et_open_config_settimeout(openconfig, tspec);
			et_open_config_setwait(openconfig, ET_OPEN_WAIT);
		}else{
			cout<<__FILE__<<":"<<__LINE__<<" Configuring input ET for direct connection" << endl;
			et_open_config_setcast(openconfig, ET_DIRECT);
			et_open_config_setmode(openconfig, ET_HOST_AS_LOCAL); // ET_HOST_AS_LOCAL or ET_HOST_AS_REMOTE
			et_open_config_sethost(openconfig, host.c_str());
			et_open_config_setport(openconfig, ET_BROADCAST_PORT);
			if(port != 0)et_open_config_setserverport(openconfig, port);
		}
	}
	
	et_sys_id sys_id;
	int err = et_open(&sys_id,fname.c_str(),openconfig);
	if(err!=ET_OK){
		cout<<__FILE__<<":"<<__LINE__<<" Problem opening input ET system"<<endl;
		cerr << et_perror(err);
		exit(-1);
	}

	// create station config in case no station exists
	et_statconfig et_station_config;
	et_station_config_init(&et_station_config);
	et_station_config_setblock(et_station_config, ET_STATION_CREATE_BLOCKING ? ET_STATION_BLOCKING:ET_STATION_NONBLOCKING);
	et_station_config_setselect(et_station_config,ET_STATION_SELECT_ALL);
	et_station_config_setuser(et_station_config,ET_STATION_USER_MULTI);
	et_station_config_setrestore(et_station_config,ET_STATION_RESTORE_IN);
	et_station_config_setcue(et_station_config,ET_STATION_NEVENTS);
	et_station_config_setprescale(et_station_config,0);
	cout<<"ET station configured\n";
	
	// create station if not already created
	et_stat_id sta_id;
	int status=et_station_create(sys_id,&sta_id,station.c_str(),et_station_config);
	if((status!=ET_OK)&&(status!=ET_ERROR_EXISTS)) { 
		et_close(sys_id);
		cerr << "Unable to create station " << station << endl;
		cerr << et_perror(status);
		exit(-1);
	}
	if(status==ET_ERROR_EXISTS){
		cout << " Using existing ET station " << station << endl;
	}else{
		cout << " ET station " << station << " created\n";
	}
	
	// Attach to the ET station
	et_att_id att_id;
	status=et_station_attach(sys_id,sta_id,&att_id);
	if(status!=ET_OK) {
		et_close(sys_id);
		cerr << "Unable to attach to station " << station << endl;
		exit(-1);
	}

	cout << "...now connected to ET system: " << fname 
		<< ",   station: " << station << " (station id=" << sta_id << ", attach id=" << att_id <<")" << endl;
		
	//input_chan = new evioETChannel(sys_id, att_id);

	// Make sure the size of event buffers we will allocate are at least as big
	// as the event size used in the ET system
	size_t eventsize;
	et_system_geteventsize(sys_id, &eventsize);
	if((uint32_t)eventsize > INPUT_BUFFER_SIZE){
		cout<<" Events in ET system are larger than currently set buffer size:"<<endl;
		cout<<" "<<eventsize<<" > "<<INPUT_BUFFER_SIZE<<endl;
		cout<<" Setting INPUT_BUFFER_SIZE to "<<eventsize<<endl;
		INPUT_BUFFER_SIZE = (uint32_t)eventsize;
	}else{
		cout<<" ET system event size:"<<eventsize<<"  INPUT_BUFFER_SIZE:"<<INPUT_BUFFER_SIZE<<endl;
	}

	// Copy system and attachment ids to global variables
	source_sys_id = sys_id;
	source_att_id = att_id;
}

//---------------------------------
// OpenOutputET
//---------------------------------
void OpenOutputET(string sink_name)
{
	// Split sink name into session, host, etc...
	vector<string> fields;
	string str = sink_name;
	size_t startpos=0, endpos=0;
	while((endpos = str.find(":", startpos)) != str.npos){
		size_t len = endpos-startpos;
		fields.push_back(len==0 ? "":str.substr(startpos, len));
		startpos = endpos+1;
	}
	if(startpos<str.length()) fields.push_back(str.substr(startpos, str.npos));

	string session = fields.size()>1 ? fields[1]:"";
	string host    = fields.size()>2 ? fields[2]:"";
	int port       = fields.size()>3 ? atoi(fields[3].c_str()):0;

	if(session == "") session = "none";
	string fname = session.at(0)=='/' ? session:(string("/tmp/et_sys_") + session);
	
	// Report to user what we're doing
	cout << " Output ET system ==================" << endl;
	if(session.at(0)!='/') cout << "          session: " << session << endl;
	cout << "      system file: " << fname << endl;
	if(host!=""){
		cout << "             host: \""<<host<<"\"" << endl;
		if(port !=0) cout << "             port: " << port << endl;
	}

	// connect to output ET system
	et_openconfig openconfig;
	et_open_config_init(&openconfig);
	et_open_config_setcast(openconfig, ET_DIRECT);
	et_open_config_setmode(openconfig, ET_HOST_AS_LOCAL);
	if(host != ""){
		if(host.find("239.")==0){
			cout<<__FILE__<<":"<<__LINE__<<" Configuring input ET for multicast" << endl;
			et_open_config_setcast(openconfig, ET_MULTICAST);
			et_open_config_addmulticast(openconfig, host.c_str());
			et_open_config_sethost(openconfig, ET_HOST_ANYWHERE);
			et_open_config_setport(openconfig, port);
			struct timespec tspec={5,5};
			et_open_config_settimeout(openconfig, tspec);
			et_open_config_setwait(openconfig, ET_OPEN_WAIT);
		}else{
			cout<<__FILE__<<":"<<__LINE__<<" Configuring input ET for direct connection" << endl;
			et_open_config_setcast(openconfig, ET_DIRECT);
			et_open_config_setmode(openconfig, ET_HOST_AS_LOCAL); // ET_HOST_AS_LOCAL or ET_HOST_AS_REMOTE
			et_open_config_sethost(openconfig, host.c_str());
			et_open_config_setport(openconfig, ET_BROADCAST_PORT);
			if(port != 0)et_open_config_setserverport(openconfig, port);
		}
	}
	
	et_sys_id sys_id;
	int err = et_open(&sys_id,fname.c_str(),openconfig);
	if(err != ET_OK){
		cerr << __FILE__<<":"<<__LINE__<<" Problem opening output ET system"<<endl;
		cerr << et_perror(err);
		return;
	}

	// Attach to the Grand Central station
	et_att_id att_id;
	int status=et_station_attach(sys_id, ET_GRANDCENTRAL, &att_id);
	if(status!=ET_OK) {
		et_close(sys_id);
		cerr << "Unable to attach to Grand Central station " << endl;
		exit(-1);
	}

	cout << "...now connected to ET system: " << fname 
		<< ",   station: Grand Central " << " ( attach id=" << att_id <<")" << endl;
		
	// Make sure the size of event buffers we will allocate are at least as big
	// as the event size used in the ET system
	size_t eventsize;
	et_system_geteventsize(sys_id, &eventsize);
	if((uint32_t)eventsize > OUTPUT_BUFFER_SIZE){
		cout<<" Events in ET system are larger than currently set buffer size:"<<endl;
		cout<<" "<<eventsize<<" > "<<OUTPUT_BUFFER_SIZE<<endl;
		cout<<" Setting OUTPUT_BUFFER_SIZE to "<<eventsize<<endl;
		OUTPUT_BUFFER_SIZE = (uint32_t)eventsize;
	}else{
		cout<<" ET system event size:"<<eventsize<<"  OUTPUT_BUFFER_SIZE:"<<OUTPUT_BUFFER_SIZE<<endl;
	}

	// Copy system and attachment ids to global variables
	sink_sys_id = sys_id;
	sink_att_id = att_id;
}

//-----------
// Usage
//-----------
void Usage(string end_message)
{

	cout<<endl;
	cout<<"Usage:"<<endl;
	cout<<"    hdet2et ET:input_fname[:station[:host[:port]]] ET:output_fname[:host[:port]]"<<endl;
	cout<<endl;
	cout<<" Example:"<<endl;
	cout<<endl;
	cout<<"   hdet2et ET:/tmp/et_gluex_FCSL3:L3:gluon46:23913 ET:/tmp/et_gluex_ER:gluonraid1:23916"<<endl;
	cout<<endl;
	cout<<"The above example will read events from the ET station"<<endl;
	cout<<"\"L3\" represented by the file \"/tmp/et_gluex_FCSL3\"" << endl;
	cout<<"running on host \"gluon46\" using port 23913 and write"<<endl;
	cout<<"them out to the ET system represented by the file " << endl;
	cout<<"\"/tmp/et_gluex_ER\" running on host \"gluondraid1\""<<endl;
	cout<<"using port 23916."<<endl;
	cout<<endl;
	if(end_message.length() > 0) cout << end_message << endl;

	exit(0);
}