//#######################################################
//#
//#  Control program for DAQ Beamtest March 2004
//#
//#  by Rok Pestotnik, Jozef STefan Institute,Ljubljana
//#  GPL licence
//#
//#  Date: 1/3/2004
#define VERSION 0.1
//#  Modifications:
//#
//#######################################################

#include <stdlib.h>
#include <stdio.h>
#include <time.h> 

#ifdef Linux
#include <sys/time.h>
#endif

#include "mycurses.h"
#include "io.h"
#include <sys/types.h>
#include <sys/stat.h>
//#include <sys/errno.h>

#include <errno.h>
#include <signal.h>

char flogfilename[128];
char datapath[128];


#define ATTR A_BLINK
#define MAXDATALEN 100000

int runno;         // run number 
int neve;          // required number of events
int ieve;          // event counter
int okeve;         // usefull events
int blen;          // buffer length 

int nrow,ncol;

char data[MAXDATALEN]; // data buffer
short * pdata;           // pointer to data

#define EVDATASIZE 10  // statistic structure
int evdata[EVDATASIZE];
float evfrac[EVDATASIZE];
int refreshrate=0x100;
FILE *fp;

int mstime; // time in ms from daq start
time_t sdtime;
time_t dum;


int camac_init( int *blen);
int camac_begin( int *blen);
int camac_event(int *mode,int *maxlen,int *blen,int* buf);
int camac_end(int *mode);
/************************************************/

# define timersubtract(a, b, result)                \
  do {                                              \
    (result).tv_sec = (a).tv_sec - (b).tv_sec;      \
    (result).tv_usec = (a).tv_usec - (b).tv_usec;   \
    if ((result).tv_usec < 0) {                     \
      --(result).tv_sec;                            \
      (result).tv_usec += 1000000;                  \
    }                                               \
  } while (0)


double Timer(){
  // returns number of seconds since EPOH
  long sec,usec;
  
  struct timeval tp;
  struct timezone tzp;


  
  gettimeofday(&tp, &tzp);
  return tp.tv_sec+ 1e-6 *tp.tv_usec;
}

int MsTimer(){
  static struct timeval firstcall;
  struct timeval dt,now;
  struct timezone tzp;
  static int first=1;


  if (first) { first=0;  gettimeofday(&firstcall, &tzp); return 0;}
  gettimeofday(&now, &tzp);
  timersubtract(now, firstcall, dt);

  return ( dt.tv_usec/1000 + dt.tv_sec*1000 );
}

int RefreshTimer(now,dt){
  static int lasttime=0;
  if (now > lasttime+dt) {
    lasttime = now;
    return 1;
  }
  return 0;
}


 /******************************************************************************
Function:       fexist()
 Description:    check the existence of file corresponding to <path>
 Parameters:     path
 Returns:        1, if file exists
 ******************************************************************************/
 static int fexist( char * path){
   struct stat sbuf;
   int res;   
   if(!path || !*path) return 0; 
   res=stat(path,&sbuf);
   if (res){
     if (errno==ENOENT) {
           return 0;
     } else {
         return -1;
     }
   }
   return 1;
}

int main_init(){
  char filename[128],lastrunfname[128];
  char line[200];
  int nr,newrunno,flag;

  FILE *flog=NULL;
  // retrive data runnumber  information from file;
  sprintf(lastrunfname,"%s/last.run",datapath);
  flog=fopen(lastrunfname,"r");
  if (flog==NULL) {
    runno=1;
  } else {
    nr=0;
    if ( fgets(line,200,flog)!=NULL) {
      nr=sscanf(line,"%d",&runno);
    }
    if (nr<=0) runno=1; else runno++;
    fclose(flog);
  }

  // write run information to stdout

  
  fprintf(stdout,"Enter the run number [%d] or confirm defaults with <Enter> to start data acquisition\n",runno);

  //  fscanf(stdin,"%s",line);
  gets(line);
  nr=sscanf(line,"%d",&newrunno);
  flag=0;
  if (nr==1){
      runno=newrunno;
      flag=1;
  } else {
     fprintf(stdout,"%c\n", line[0]);
    //if (line[1]==0 && line[0]=='y' ) flag=1;
    if (line[0]==0) flag=1;
  }
  if (flag==0) exit(1);

  sprintf(filename,"%s/r%07d.dat",datapath,runno);

  if (fexist(filename)==1){
    fprintf(stdout,"Error !\n");
    fprintf(stdout,"Run %d with name %s already exist\n",runno,filename);
    fprintf(stdout,"Remove the the run and restart !!!\n");
    exit(0);
  } 

    
  // write current data runnumber to file;

  flog=fopen(lastrunfname,"w");
  fprintf(flog,"%d",runno);
  fclose(flog);

  // write BEGIN_RECORD information to log

  flog=fopen(flogfilename,"a");
  if (flog==NULL) {
    return -1;
  } else {
    sdtime = time(NULL);
    sprintf(line,"%s",ctime(&sdtime));
    line[strlen(line)]=0;
    fprintf(flog,"Run %d %s START:%d COMPILED on  %s %s ",
	    runno,filename,sdtime,__DATE__,__TIME__);
    fprintf(stdout,"Run %d %s START:%d COMPILED on  %s %s ",
	    runno,filename,sdtime,__DATE__,__TIME__);

    fclose(flog);
  }

  // open data file
  fp=fopen(filename,"w");
  if (fp==NULL) {
    fprintf(stderr,"File %s cannot be opened. Exiting...\n",filename);
    exit(-1);
  }
  // write BEGIN_RECORD information to file

  Ewrite(BEGIN_RECORD_TYPE,runno,neve,0,0,(void *) &nr,fp);

  // reset counters
  for (nr=0;nr<EVDATASIZE;nr++) evdata[nr]=0;

  return 0;
}
/************************************************/
int main_end(){
  char line[200],l1[200];
  FILE *flog=NULL;
  // write END_RECORD information to data
  Ewrite(END_RECORD_TYPE,runno,ieve,0,0,line,fp);
  if (fp!=NULL) fclose(fp);

  // create END_RECORD information
  sdtime=time(NULL);
  sprintf(l1,"Run %d Recorded=%d STOP time=%d\n",runno,okeve,sdtime);
  mvprintw(nrow-1,0,l1);

  // write END_RECORD information to logfile
  flog=fopen(flogfilename,"a");  
  if (flog!=NULL){
    fprintf(flog,l1);
    fclose(flog);
  }


  return 0;

}


/************************************************/
int main_keyboard_event(){

  // decode the character *p
  char p[2];
  int len;

    
  if (!my_getc_ (p, len)) {
    p[1]=0;
    mvprintw(1,ncol,p);
  } else {
    return 0;
  }
    
  switch (*p){

  case 's': 
    attron(ATTR);
    mvprintw(nrow,0,"Do you really want to stop?");
    attroff(ATTR);
    refresh();   
    wait_key_();
    my_getc_(p, len);
    mvprintw(nrow,0,"                            ");

    if (*p=='y') {
     return -1;
    }
    return 0;
    break;

  default:
    return 0;

  }
  return 0;
}


int main_statistics(int y, int x,int *evdata,float *evfrac, int okeve){
  
  char tmp[255];
  static int lasteve=0;
  static double lasttime;
  double dt,curtime;
  static int mem[10];
  static int imem=0;
  int kk,kmax=10;
  
  int n;
  n=evdata[0]+evdata[1];
  if (n) {
    evfrac[0]=  (float) evdata[0]/n ; 
    evfrac[1]=  (float) evdata[1]/n ; 
  } else { 
    evfrac[0]=0;
    evfrac[1]=0;
  }
  n=okeve-lasteve;
  curtime=MsTimer()/1000.;
  dt=curtime-lasttime; 
  if (dt>0) {
    evfrac[3]= n / dt;
  } else {
    evfrac[3]=0;
  }
  mem[imem]=evfrac[3];
  imem++;
  imem%=kmax;
  evfrac[8]=0;
  for( kk=0;kk<kmax;kk++) evfrac[8]+=mem[imem];
  evfrac[8]/=kmax;
  lasttime = curtime;
  lasteve  = okeve;
  evfrac[2]=(float)evdata[2]/(ieve+1);
  evfrac[5]=(float)evdata[5];
  evfrac[6]=(float)evdata[6];
  evfrac[7]=(float)evdata[7];
  if (curtime > 0){
    evfrac[4]=(okeve)/curtime;
  } else {
    evfrac[4]=0;
  }
  
  mvprintw(1,ncol-30,"%5.1f s",curtime);

  sprintf(tmp,"%7d %7d %7d %7d %7d     %5.2f     %5.2f\n",ieve+1,blen, 
                  evdata[0],evdata[1],evdata[2],evfrac[8],evfrac[4]);
  mvprintw(y,x,tmp);

  printw("Fractions:          %5.1f   %5.1f   %5.1f \n", 
          100*evfrac[0],100*evfrac[1],100*evfrac[2]);

  printw("Buffers: MCP: %5.1f RICH2: %5.1f MWPC: %5.1f",evfrac[5],evfrac[6],evfrac[7]);
  return 0;
}


     


int dumpdata(int n, void *mem){
  // dump part of data on the screen
  short *ptr=(short*) data;
  int i,j;
  char tmp[256];
  static int short_size=sizeof(short);
  const int nadc=4;
  const int nch=256;
  int of = 50 + 2*(ptr[5]+ptr[6]+ptr[7]);
  sprintf(tmp,"Bytes:%d\nAdc\n",n);
  printw(tmp);
  if ( n >= of+nadc*nch ) {
    for (i=0;i<nadc;i++){
      for (j=0;j<10;j++){
	sprintf(tmp,"%7d ",ptr[of+i*nch+j]);
        printw(tmp);
      }
      printw("\n");
    }
  }
  return 0;
}

int main_help(int i, char *h, char *sh){

  attron(ATTR);
  mvprintw(nrow-1,i*15,sh);
  attroff(ATTR);
  mvprintw(nrow-1,i*15+3,h);

}

int main_screen_redraw(){

  int nhelp=1,i;
  char help[][15]={"Exit Ctrl-C","Statistics","Continue" };
  char shelp[][2]={"S","T","C" };
  attron(ATTR);
  mvprintw(1,0,"ARich Beamtest 04: Run %d  will record %d events\n",runno,neve);
  set_term("[J");
  mvprintw(1,ncol-15,"Last command:");
  mvprintw(1,ncol-38,"Timer:");

  attroff(ATTR);

  mvprintw(2,0,"Event     Size      OK      SHIFT    NBUF   Rate(Hz) <Rate(Hz)>\n");

  for (i=0;i< nhelp;i++)    main_help(i,help[i],shelp[i]);
  return 0;
}


/* ------------------- CatchSig ----------------- */
int ctrlcflag=0;

void CatchSig ()
{
    ctrlcflag = 1;
}



int main(int argc,char **argv){
  int maxlen=MAXDATALEN;


  int waskey;
  int x[3]={0,15,0},y[3]={3,5,7}; // cursor positions
  int flag=0;
  int mode=0;
  int eveflag;

  char tmp[256];
  time_t t;
  int n;

   // intercept routine
   if (signal (SIGINT, CatchSig) == SIG_ERR) {
        perror ("sigignore");
   }


  open_inkey_();
  n=get_term_size(&nrow, &ncol);
  close_inkey_();


  // print usage
  if (argc<2){
    fprintf(stdout,"Usage: %s <datapath> <nevents> <refresh_every_n_events>\n",argv[0]);
    fprintf(stdout,"nevents < 0 take data run forever\n");
    exit(0);
  }
  // decode program arguments
  if (argc>1) sprintf(datapath,"%s",argv[1]);
  if (argc>2) neve=atoi(argv[2]); else neve=50000;
  if (argc>3) refreshrate=atoi(argv[3]); else  refreshrate=1000;
  sprintf(flogfilename,"%s/daq.log",datapath);

  // print welcome message
  time(&t);

  fprintf(stdout,"#############################################\n");
  fprintf(stdout,"Program %s version %2.1f\n",argv[0], VERSION);
  fprintf(stdout,"Compiled on %s %s\n",__DATE__, __TIME__);
  fprintf(stdout,"Runtime  %s \n",ctime(&t));
  fprintf(stdout,"#############################################\n");
 

  blen=0;
  pdata = (short *) data;

  main_init();

  // initialize daq
#ifdef SUN
  camac_init(&mode);
  camac_begin(&mode);
#endif
  
  // screen and key manager
  initscr();
  main_screen_redraw();
  // event loop
  okeve=0;
  while ( ((okeve<neve) || (neve<0)) && !flag && !ctrlcflag){
#ifdef SUN
     camac_event(&mode,&maxlen,&blen, (int *) data );
#else
     if (ctrlcflag) break;
     for(blen=0;blen<10;blen++)  pdata[blen]=0;
     for(blen=10;blen<30;blen++) pdata[blen]=1;
     for(blen=30;blen<1054;blen++) pdata[blen]=blen-30;
     blen++; 
#ifdef Linux
     system("sleep 0.001");
#else
     system("sleep 1");
#endif
     if (rand()> RAND_MAX/2) pdata[3]=256;
#endif

     if( pdata[4]==256 ) {               // complete buffer       
       if (pdata[9] & 0x1) evdata[1]++;  // data shifted
       else evdata[0]++;                 // data nonshifted
     } else evdata[2]++;                 // incomplete buffer

     evdata[5]=pdata[5];
     evdata[6]=pdata[6];
     evdata[7]=pdata[7];
         
     mstime=MsTimer();
     //     mvprintw(nrow-2,0,"Time %d, %d",mstime,refreshrate);
     if ( RefreshTimer(mstime,refreshrate)){
       main_statistics(y[0],x[0],evdata, evfrac, okeve);
       move(y[2],x[2]);
       dumpdata(blen,data);
     }
     eveflag=     (pdata[4]==256);      // usefull event flag
     if (eveflag){
       Ewrite(EVENT_RECORD_TYPE,runno,ieve,mstime,blen,data,fp);
       okeve++;
     }
     ieve++;
     key_ready_ (&waskey);
     if (waskey) flag=main_keyboard_event();
  }
  
  endwin();
 if (ctrlcflag) printf("User Program termination CTRL-C\n");
#ifdef SUN
  camac_end(&mode);
#endif

  main_end();
  //system("reset");
  return 0;
}