//  evio2et

// Reads evio events from a file and inserts into ET system
// Rereads file at eof
// Adds run and event number if requested

// Still to do:


//  ejw, 8-jul-2013


// Disable building in codaobject support, even if it is available.
// This functionality was included by Elliott so this could be used
// while testing the DAQ in some integrated way. At this point, I want
// to use it without any CODA system integration. The easiest thing to
// do is disable it here so that it can be easily resurrected in the
// future if needed.
//  8/22/2014  DL
#ifdef HAVE_CODAOBJECTS
#undef HAVE_CODAOBJECTS
#endif


#include <string>
#include <memory>
#include <iostream>
#include <iomanip>
#include <unistd.h>
#include <time.h>
#include <signal.h>
#include <pthread.h>
using namespace std;



// for et
#include <et.h>


// for evio
#include "evioUtil.hxx"
#include <evioFileChannel.hxx>
#include <evioBufferChannel.hxx>
using namespace evio;


#ifdef HAVE_CODAOBJECTS
// for coda object package
#include <RunObject.hxx>
using namespace codaObject;
#endif

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


// misc variables
static string udl                = "cMsg://localhost/cMsg";
static string name               = "evio2et";
string evioFilename              = "eviofile.dat";
static string startup_session;
static int chunk                 = 200;     // number buffers to get from ET at one go
static int delay_time         	 = 0;       // in msecs between events
static int rate_time           	 = 2;      // in secs
static uint64_t max_event        = 0;
static int max_event_file        = 0;
static int max_len               = 120000;  // in bytes
static int max_file              = 0;
static bool et_ok                = false;
static bool connected            = false;
static bool debug                = false;
static bool no_fill              = false;
static bool no_write             = false;
static bool no_buffer            = false;
static bool no_memcpy            = false;
static bool force_start          = false; // will be set to true in evio2et constructor if no CODA objects
static bool processing           = false;
static bool done                 = false;


// for performance stats, etc.
static uint64_t nev_read       	 = 0;
static uint64_t nev_too_long   	 = 0;
static uint64_t nev_to_et      	 = 0;
static uint64_t nev_this_run   	 = 0;
static time_t last_time          = time(NULL);
static uint64_t last_rec         = 0;
static uint64_t last_proc        = 0; 
static uint64_t last_too_long    = 0; 
static double read_rate;
static double proc_rate;
static double too_long_rate;

// et stuff
static et_sys_id et_system_id;
static et_openconfig openconfig;
static string et_filename        = "/tmp/et_sys_test";
static et_att_id et_attach_id;
//static et_event *et_event_ptr;
static et_event  **pevents;
static int et_control[ET_STATION_SELECT_INTS];
static size_t etbuffersize;


// other prototypes
void decode_command_line(int argc, char **argv);
void connect_et(void);



//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------

#ifndef HAVE_CODAOBJECTS

class evio2et {

public:
  evio2et() {
  	force_start = true;
    cout << "evio2et withOUT CODA Object support" << endl;
  }

//-----------------------------------------------------------------------------


  ~evio2et(void) throw() {}
  
}; // end evio2et class definition for when CODA objects not present
  
//-----------------------------------------------------------------------------

#else  // HAVE_CODAOBJECTS

class evio2et : public RunObject {

public:
  evio2et(const string& UDL, const string& name, const string& descr, const string &theSession) : 
    RunObject(UDL,name,descr) {

    cout << "evio2et with CODA Object support" << endl;

    // set session if specified
    if(!theSession.empty())handleSetSession(theSession);
  }


  ~evio2et(void) throw() {
    done=true;
  }
  
//-----------------------------------------------------------------------------


  bool userConfigure(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userDownload(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userPrestart(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userGo(const string& s) throw(CodaException) {
    nev_this_run=0;
    processing=true;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userPause(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userResume(const string& s) throw(CodaException) {
    processing=true;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userEnd(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  bool userReset(const string& s) throw(CodaException) {
    processing=false;
    return(true);
  }


//-----------------------------------------------------------------------------


  void exit(const string& s) throw(CodaException) {
    cout << "evio2et received exit command" << endl;
    processing=false;
    done=true;
  }
  

//-----------------------------------------------------------------------------


  void userMsgHandler(cMsgMessage *msgp, void *userArg) throw(CodaException) {
    //unique_ptr<cMsgMessage> msg(msgp);
    cMsgMessage *msg = msgp;
    string subject = msg->getSubject();

    if(subject=="delay") {     // in msecs
      delay_time=atoi(msg->getText().c_str());
      cout << "evio2et userMsgHandler...new delay time is: " << delay_time << endl;

    } else if(subject=="rate") {   // in secs
      rate_time=atoi(msg->getText().c_str());
      cout << "evio2et userMsgHandler...new rate time is: " << rate_time << endl;
      
    } else {
      cerr << "?evio2et...received unknown message subject,type: "
           << msg->getSubject() << "," << msg->getType() << endl << endl;
    }
  }

//-------------------------------------------------------------------------------
// end class definition
//-------------------------------------------------------------------------------
};
#endif //HAVE_CODAOBJECTS


static void* monitoring_thread(void *arg) {

  time_t now;

  while(true) {
    
    // sleep
    if(rate_time>0) {
      sleep(rate_time);
    } else {
      sleep(1);
    }
    
    now=time(NULL);
    if((rate_time>0)&&(now-last_time)>rate_time) {
      int delta=now-last_time;
      read_rate=(double)(nev_read-last_rec)/(double)delta;
      proc_rate=(double)(nev_to_et-last_proc)/(double)delta;
      too_long_rate=(double)(nev_too_long-last_too_long)/(double)delta;
      last_time=now;
      last_rec=nev_read;
      last_proc=nev_to_et;
      last_too_long=nev_too_long;
      
      cout
        << "      nev_read:       " << nev_read << " events" << endl
        << "      read_rate:      " << (int)read_rate << " Hz" << endl
        << "      nev_to_et:      " << nev_to_et << " events" << endl
        << "      proc_rate:      " << (int)proc_rate << " Hz" << endl
        << "      nev_too_long:   " << nev_too_long << endl
        << "      too_long_rate:  " << (int)too_long_rate  << endl
        << "      nev_this_run:   " << nev_this_run  << endl
        << "      processing:     " << processing << endl
        << endl;
    }
  }

	return NULL;
}


//-------------------------------------------------------------------------------


int main(int argc,char **argv) {
  
  int status, filecount=0, evfilecount, nDumped;
  bool eof=false;
  const uint32_t *pevio = NULL;
  int length,etBufferCount;
  uint32_t *pdata;
  int padding = 100;


  // decode command line
  decode_command_line(argc,argv);
  cout << endl << "evio2et using chunk = " << chunk << endl << endl;


#ifdef HAVE_CODAOBJECTS

  // set session name
  if(startup_session.empty())startup_session="halldsession";

#endif // HAVE_CODAOBJECTS

  // launch monitoring thread
  //thread t(monitoring_thread);
	pthread_t t;
	pthread_create(&t, NULL, monitoring_thread, NULL);


  // allocate pevents array
  pevents = (et_event **) calloc(chunk, sizeof(et_event*));
  if (pevents == NULL) {
    cerr << "unable to allocate events array, chunk is " << chunk << endl;
    exit(EXIT_FAILURE);
  }


  try {

	// create coda object and start processing
#ifdef HAVE_CODAOBJECTS
	evio2et c(udl, name, "evio2et", startup_session);
    cout << "Process startup:  " << name << " in session " << c.getSession() <<endl;
#else
	evio2et c;
#endif // HAVE_CODAOBJECTS


	// create station config
	et_open_config_init(&openconfig);
	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, "localhost");  // for some reason, using ET_HOST_LOCAL doesn't work ???
	//et_open_config_sethost(openconfig, ET_HOST_LOCAL);
	//et_open_config_sethost(openconfig, host.c_str());
	//et_open_config_setport(openconfig, ET_BROADCAST_PORT);
	//et_open_config_setserverport(openconfig, 11111);


	// connect to ET system
	connected=false;
	if(debug)cout << endl << "trying to connect to ET system..." << endl;
	connect_et();
	et_open_config_destroy(openconfig);

	if(!connected){
		cout << endl;
		cout << "Unable to establish connection to ET system." << endl;
		cout << "Try starting one with:" << endl;
		cout << endl;
		cout << "    et_start -f /tmp/et_sys_tmp -n 100 -s 21000 -d" << endl;
		cout << endl;
		exit(EXIT_FAILURE);
	}
	cout << "Connected to ET system!" << endl << endl;

    // create and open evio file channel
	cout << "Opening EVIO file \"" << evioFilename << "\"" << endl;
    //unique_ptr<evioFileChannel> chan(new evioFileChannel(evioFilename,"r"));
    evioFileChannel *chan =new evioFileChannel(evioFilename,"r");


#ifdef HAVE_CODAOBJECTS
    // start coda object processing
    c.startProcessing();
#endif // HAVE_CODAOBJECTS

    // force start
    processing = force_start;

    // event processing loop
    filecount=0;
    while(!done) {

      if(!processing) {
        sleep(1);
        
      } else {

        // open/read/close evio file as many times as needed
        evfilecount=0;

        while(!done && processing && ((max_file<=0)||(filecount<max_file)) && ((max_event<=0)||(nev_to_et<max_event)) ) {
          filecount++;
          evfilecount=0;
          chan->open();
      

          // fill et buffers with evio events, reopen file if needed
          while(!done && processing &&
                ((max_event_file<=0)||(evfilecount<max_event_file)) && ((max_event<=0)||(nev_to_et<max_event)) ) {
            
        
            // get some et buffers, may not get as many as requested
            status = et_events_new(et_system_id, et_attach_id, pevents, ET_SLEEP, NULL, max_len, chunk, &etBufferCount);
            if((status != ET_OK)||(etBufferCount<=0)) {
              cerr << "?unable to get new events" << endl;
              exit(EXIT_FAILURE);
            }
        
        
            // fill et buffers with evio events from file
            nDumped=0;
            for(int i=0; i<etBufferCount; i++) {
          
              // delay if requested
              if(delay_time>0)usleep(delay_time*1000);


              // get evio event from file
              eof=!chan->readNoCopy();
              if(!eof) {
                nev_read++;
                evfilecount++;
                pevio=chan->getNoCopyBuffer();
                length=(pevio[0]+1)*sizeof(uint32_t) + padding;
            
            
                // check if event fits into et buffer, must account for block headers
                if(length<(max_len)) {
              
                  // get ET buffer data pointer
                  et_event_getdata(pevents[i],(void**)&pdata);
                  if(pdata==NULL) {
                    cerr << "?null pdata" << endl;
                    exit(EXIT_FAILURE);
                  }
              
                  // set control words...must set 1st word > 32 to not fool CODA
                  et_control[0]=0x21;
                  for(int ii=1; ii<ET_STATION_SELECT_INTS; ii++) et_control[ii]=0;
                  et_event_setcontrol(pevents[i],et_control,ET_STATION_SELECT_INTS);
              
                  // fill et buffer, add event number, add run number if space exists
                  if(!no_fill) {
                    nev_to_et++;
                    nev_this_run++;
                    if(no_buffer) {
                      if(!no_memcpy) {
                        memcpy((void*)pdata,(void*)pevio,(pevio[0]+1)*sizeof(uint32_t));
                        et_event_setlength(pevents[i],(pevio[0]+1)*sizeof(uint32_t));
                      }

     // *((uint64_t*)(&(pdata[3])))=nev_this_run;
     // if()pdata[2*m+8]=c.getRunNumber();  ??? what is m ???


                    } else {
                      evioBufferChannel etChan((uint32_t*)pdata,max_len/sizeof(uint32_t),"w");
                      etChan.open();
                      if(!no_write)etChan.write(pevio);
                      et_event_setlength(pevents[i],etChan.getEVIOBufferLength()*sizeof(uint32_t));
                      etChan.close();
     //                      pdata[block_header_size+3]=nev_this_run;  // ???
                    }
                  }

              
                } else {
                  nev_too_long++;
                  cerr << "event too large for et buffer: " << length << endl;
                }
            
              } else {
            
                // eof, dump extra events
                nDumped=etBufferCount-i;
                status = et_events_dump(et_system_id, et_attach_id, &(pevents[i]), nDumped);
                break;
              }
            }
        

            // return et buffers
            status = et_events_put(et_system_id, et_attach_id, pevents, etBufferCount-nDumped);
            if (status != ET_OK) {
              cerr << "?unable to put events" << endl;
              exit(EXIT_FAILURE);
            }
            if(eof)break;
          }

          // close channel
          chan->close();
        }

     }

    }


#ifdef HAVE_CODAOBJECTS
    // stop processing
    c.stopProcessing();
#endif // HAVE_CODAOBJECTS
    
  } catch (evioException e) {
	cerr << "evioException caught:" << endl;
    cerr << e.toString() << endl;
    
#ifdef HAVE_CODAOBJECTS
  } catch (CodaException e) {
	cerr << "CodaException caught:" << endl;
    cerr << e.toString() << endl;
#endif // HAVE_CODAOBJECTS
    
  } catch (...) {
    cerr << "?unknown exception" << endl;
  }
  
  
  // done
  cout << endl
       << " *** evio2et shutdown after reading " << nev_read << "(" << filecount << ") events(files), inserting " << nev_to_et << " events ***" 
       << endl << endl;
  if(connected)et_forcedclose(et_system_id);
}


//--------------------------------------------------------------------------


void connect_et() {
  
    int status;
    sigset_t sigblock;


    // open et system
    if(et_open(&et_system_id,et_filename.c_str(),openconfig)!=ET_OK) {
      cerr << "?connect_et...bad return from et_open" << endl;
      return;
    }


    // block signals to THIS thread and any thread created by this thread
    // needed to keep signals from et threads
    sigfillset(&sigblock);
    pthread_sigmask(SIG_BLOCK,&sigblock,NULL);


    // attach to grandcentral
    status=et_station_attach(et_system_id,ET_GRANDCENTRAL,&et_attach_id);
    if(status!=ET_OK) {
      et_forcedclose(et_system_id);
      cerr << "?unable to attach to grandcentral station" << endl;
      return;
    }
  

    // unblock signals
    pthread_sigmask(SIG_UNBLOCK,&sigblock,NULL);


    // now connected
    if(debug)cout << "...connection to grandcentral established" << endl;
    et_system_geteventsize(et_system_id,&etbuffersize);
    if(debug)cout << "Default ET event size = " << etbuffersize << endl;
    connected=true;
    et_ok=true; 


    return;
  }


//---------------------------------------------------------------------


void decode_command_line(int argc, char**argv) {

  const string help = "\nUsage:\n\n  evio2et [-udl udl] [-n name] [-s session] [-force]\n"
    "          [-delay delay_time] [-rate rate_time]\n" 
    "          [-max_event max_event] [-max_file max_file] [-max_ev_file max_event_file]\n"
    "          [-max_len max_len] [-chunk chunk]\n"
    "          [-no_fill] [-no_write] [-no_buffer] [-no_memcpy]\n"
    "          [-evio evioFilename] [-et et_filename] [-debug]\n";


  int i=1;
  while(i<argc) {
    if(strncasecmp(argv[i],"-h",2)==0) {
      cout << help << endl;
      exit(EXIT_SUCCESS);

    } else if (strncasecmp(argv[i],"-debug",6)==0) {
      debug=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-no_fill",8)==0) {
      no_fill=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-no_write",9)==0) {
      no_write=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-no_buffer",10)==0) {
      no_buffer=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-no_memcpy",10)==0) {
      no_memcpy=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-chunk",6)==0) {
      chunk=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-delay",6)==0) {
      delay_time=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-evio",5)==0) {
      evioFilename=argv[i+1];
      i=i+2;

    } else if (strncasecmp(argv[i],"-et",3)==0) {
      et_filename=argv[i+1];
      i=i+2;

    } else if (strncasecmp(argv[i],"-rate",5)==0) {
      rate_time=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-max_ev_file",12)==0) {
      max_event_file=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-max_event",10)==0) {
      max_event=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-max_len",8)==0) {
      max_len=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-max_file",9)==0) {
      max_file=atoi(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-force",6)==0) {
      force_start=true;
      i=i+1;

    } else if (strncasecmp(argv[i],"-udl",4)==0) {
      udl=string(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-n",2)==0) {
      name=argv[i+1];
      i=i+2;

    } else if (strncasecmp(argv[i],"-s",2)==0) {
      startup_session=string(argv[i+1]);
      i=i+2;

    } else if (strncasecmp(argv[i],"-",1)==0) {
      cout << "?unknown command line arg: " << argv[i] << " " << argv[i+1] << endl << endl;
      i=i+1;

    } else {
      i=i+1;
    }
  }

  return;
}

  
//----------------------------------------------------------------