/*----------------------------------------------------------------------------*
 *  Copyright (c) 1998        Southeastern Universities Research Association, *
 *                            Thomas Jefferson National Accelerator Facility  *
 *                                                                            *
 *    This software was developed under a United States Government license    *
 *    described in the NOTICE file included as part of this distribution.     *
 *                                                                            *
 *    Author:  Carl Timmer                                                    *
 *             timmer@jlab.org                   Jefferson Lab, MS-12H        *
 *             Phone: (757) 269-5130             12000 Jefferson Ave.         *
 *             Fax:   (757) 269-5800             Newport News, VA 23606       *
 *                                                                            *
 *----------------------------------------------------------------------------*
 *
 * Description:
 *      A very simple ET event producer
 *
 *----------------------------------------------------------------------------*/

#include <string>
#include <iostream>
#include <cmath>
using namespace std;

#include <stdio.h>
#include <stdlib.h>
#include "et.h"

#define _DBG_ cerr<<__FILE__<<":"<<__LINE__<<" "
#define _DBG__ cerr<<__FILE__<<":"<<__LINE__<<endl

void Usage(int exit_code=-1);


//-------------------------
// main
//-------------------------
int main(int argc,char **argv)
{
	string fname = "/tmp/et_sys_username";
	string host = "127.0.0.1";
	int port = 1111;
	int event_size = 1000; // bytes
	int events_per_chunk=500;
	bool use_muticast = false;
	int max_chunks = 0; // maximum number of chunks to send (0=infinite)
	
	if(argc<2) Usage();
	
	for(int i=1; i<argc; i++){
		string arg = argv[i];
		string next = ((i+1)<argc) ? argv[i+1]:"";
		bool missing_arg = false;

		if(arg == "--help") Usage(0);

		if(arg == "-f"){
			if(next=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			fname = next;
		}
		if(arg == "-h"){
			if(arg=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			host = next;
		}
		if(arg == "-p"){
			if(arg=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			port = atoi(next.c_str());
		}
		if(arg == "-e"){
			if(arg=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			events_per_chunk = atoi(next.c_str());
		}
		if(arg == "-s"){
			if(arg=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			event_size = atoi(next.c_str());
		}
		if(arg == "-c"){
			if(arg=="" || (next.size()>0 && next[0]=='-')) missing_arg = true;
			max_chunks = atoi(next.c_str());
		}
		if(arg == "-m"){
			use_muticast = true;
		}
		
		if(missing_arg){
			cout << endl;
			cout << "Option \"" << arg << "\" requires and argument!" << endl;
			cout << endl;
			Usage();
		}
	}
	
	char max_chunks_str[256];
	sprintf(max_chunks_str, "%d", max_chunks);
	
	cout << endl;
	cout << "Will attach with the following:" <<endl;
	cout << "------------------------------------------" << endl;
	cout << "            method = " << (use_muticast ? "multi-cast":"direct") << endl;
	cout << "          filename = " << fname << endl;
	cout << "              host = " << host << endl;
	cout << "              port = " << port << endl;
	cout << "  events per chunk = " << events_per_chunk << endl;
	cout << "        event size = " << event_size << endl;
	cout << " max. chunks to send = " << (max_chunks>0 ? max_chunks_str:"infinite") << endl;
	cout << endl;

  
	et_att_id  attach;
	et_sys_id  id;
	et_event   **pes = new et_event*[events_per_chunk];
	et_openconfig   openconfig;
  

	// opening the ET system is the first thing we must do
	et_open_config_init(&openconfig);
	et_open_config_setmode(openconfig,ET_HOST_AS_REMOTE);
	if(use_muticast){
		et_open_config_setcast(openconfig, ET_MULTICAST);
		et_open_config_sethost(openconfig, ET_HOST_REMOTE);
		et_open_config_addmulticast(openconfig, host.c_str());
		//et_open_config_setmultiport(openconfig, port);
	}else{
		et_open_config_setcast(openconfig, ET_DIRECT);
		et_open_config_sethost(openconfig, host.c_str());
		et_open_config_setserverport(openconfig, port);
	}

	if (et_open(&id, fname.c_str(), openconfig) != ET_OK) {
		printf("et_blaster: et_open problems\n");
		exit(1);
	}

	et_open_config_destroy(openconfig);

	// set the level of debug output that we want (everything)
	et_system_setdebug(id, ET_DEBUG_INFO);

	// attach to GRANDCENTRAL station since we are producing events
	if (et_station_attach(id, ET_GRANDCENTRAL, &attach) < 0) {
	printf("et_blaster: error in station attach\n");
		exit(1);
	}

	int Nchunks = 0;
	while (et_alive(id)) {
		// get new/unused chunk of events
		int nread;
		int status = et_events_new(id, attach, pes, ET_SLEEP, NULL, event_size, events_per_chunk, &nread);
		if (status != ET_OK) {
			printf("et_blaster: error in et_event_new\n");
			exit(-1);
		}

		// put events back into the ET system
		status = et_events_put(id, attach, pes, nread);
		if (status != ET_OK) {
			printf("et_blaster: put error\n");
			exit(-2);
		}
		
		// Optional limit on number of chunks
		Nchunks++;
		if(max_chunks>0 && Nchunks>=max_chunks)break;

		// Wait for ET system to revive
		if (!et_alive(id)) {
			et_wait_for_alive(id);
		}
	} // while(alive)

	delete[] pes;
	
	double kB_sent = ((double)Nchunks*(double)events_per_chunk*(double)event_size)/1024.0;
	double MB_sent = kB_sent/1024.0;
	double GB_sent = MB_sent/1000.0;
	int value = (int)round(kB_sent);
	string units="kB";
	if(kB_sent>10000.0){value = (int)round(MB_sent); units="MB";}
	if(MB_sent>10000.0){value = (int)round(GB_sent); units="GB";}
	cout << Nchunks << " chunks (=" << Nchunks*events_per_chunk << " events = " << value << " " << units << ") sent" << endl;
 
cout << kB_sent << "kB" <<endl;
cout << MB_sent << "MB" <<endl;
cout << GB_sent << "GB" <<endl;


 	return 0; 
}


//-------------------------
// Usage
//-------------------------
void Usage(int exit_code)
{
	cout << endl;
	cout << "Usage: et_blaster [options] -f <et_filename> -h host -p port" << endl;
	cout << endl;
	cout << "  options:" <<endl;
	cout << "    -h       Print this usage statement" << endl;
	cout << "    -f file  Set the ET file name" << endl;
	cout << "    -h host  Set the host (see note below)" << endl;
	cout << "    -p port  Set the port (see note below)" << endl;
	cout << "    -e #     Set number of ET events to produce at a time" << endl;
	cout << "    -s #     Size of events in bytes" << endl;
	cout << "    -c #     Maximum number of chunks to send before exiting (o=infinite)" << endl;
	cout << "    -m       Use multi-cast instead of a direct connection" << endl;
	cout << endl;
	cout << "If the \"-m\" option is given, then the host will be " << endl;
	cout << "found via multi-cast. In this case, the values passed " << endl;
	cout << "for \"host\" and \"port\" will be interpreted as the" << endl;
	cout << "multicast address and the multicast port. To find these" << endl;
	cout << "for an existing system, you can attach with et_monitor " << endl;
	cout << "and look for the port in \"ET SYSTEM\" section and the" << endl;
	cout << "address in the \"STATIC INFO\" section." << endl;
	cout << endl;

	exit(exit_code);
}