/* 
 * eb_pr.c
 * Example program on how to integrate the DD system
 * into the RC callable routines of  CODA
 * 
 * CW Jan 9, 1995
 * YK July ,1997
 *
 */

#include <stdio.h>      
#include <time.h>
#include <errno.h>          
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>

#include <dd_sys.h>
#include <dd_user.h>
#include <db.h>         

#include "da.h"           
#include "services.h"
#include "usr.h"


#define TRUE 1
#define FALSE 0

/* delete remaining proc and stuffs. */ 
void clean()
{
 system("$DD_BIN/dd_cleanup");
}


int usrpause_()             
{   
  int status;
  time_t t; 
  struct fifo_entry fev;
  struct coda_event pb_event;
  
  if ( status = ddu_req_fev(sizeof(struct coda_event)/4,&fev) ){
    /*------> request a fifo_entry of which size is 
              (sizeof(struct coda_event)/4 byte --------------*/
    fprintf(stderr,"usrPrestart: ddu_req_feq failed:%d\n",status);
  }
  else{
    fev.ctlw1 = PAUSE_EVENT;
    fev.ctlw2 = -1;
    fev.ctlb1 = -1;
    fev.ctlb2 = -1;            
    fev.len = 5;

    pb_event.xwc = 4;
    pb_event.flag = PAUSE_EVENT<<16 | 1<<8;

    pb_event.buffer[0] = pb_event.xwc;
    pb_event.buffer[1] = pb_event.flag;
    pb_event.buffer[2] = (int) time(&t);
    pb_event.buffer[3] = 0;
    pb_event.buffer[4] = 0;  

    memcpy(fev.p2da, &pb_event.buffer, 4*(pb_event.xwc+1) );
    if ( status = ddu_brc_fev(fev,2000) ){
     /*-------> distribute pb_event. wating time is 2000ms -------*/
          fprintf(stderr,"usrPause: ddu_brc_fev failed:%d\n",status);
        }
  }
}                          

int usrgo_()
{   
    int status;
    time_t t;
    struct fifo_entry fev;
    struct coda_event gb_event;

  if ( status = ddu_req_fev(sizeof(struct coda_event)/4,&fev) ){
     /*------> request fifo_entry -------*/
    fprintf(stderr,"usrPrestart: ddu_req_feq failed:%d\n",status);
  }
  else{
    fev.ctlw1 = GO_EVENT;
    fev.ctlw2 = -1;
    fev.ctlb1 = -1;
    fev.ctlb2 = -1;            
    fev.len = 5;

    gb_event.xwc = 4;
    gb_event.flag = GO_EVENT<<16 | 1<<8;

    gb_event.buffer[0] = gb_event.xwc;
    gb_event.buffer[1] = gb_event.flag;
    gb_event.buffer[2] = (int) time(&t);
    gb_event.buffer[3] = 0;
    gb_event.buffer[4] = 0;  

    memcpy(fev.p2da, &gb_event.buffer, 4*(gb_event.xwc+1) );
    if ( status = ddu_brc_fev(fev,2000) ){
      /*-------> broadcasting go_event ----------*/
          fprintf(stderr,"usrGo: ddu_brc_fev failed:%d\n",status);
        }
  }
}

int usrdump_()
{
}                                                            

int usrdownload_(char *config)  
{
  char *p,ntupleOk;
  int status,brc_flag;
  int dd_ctl[FIFO_HDR_CTL_LEN] = {-1,-1,-1,-1};  
  struct fifo_mode eb_fmode;
  char eb_fname[20];
  
  /*---------> creates dd_system. ie, makes event buffers and fifos
               connects input_fifo and event buffers <--------------*/
  if ( status = dds_create() ) 
    return status;

  printf("usrdownload: dds_create = %d\n",status);
  fflush(stdout);
   
  eb_fmode.mode = FMODE_ALL;
  eb_fmode.prescale = 1;
  eb_fmode.wait = FWAIT_SLEEP;
  eb_fmode.suser = FMODE_MULTI_USER;   
  eb_fmode.p2ctl = dd_ctl;  
  strcpy(eb_fname,"INPUT");
  status = ddu_init(eb_fname,eb_fmode); /*--> attaches fifo <---*/
  printf("\nusrdownload: ddu_init = %d\n",status);
 
/*  printf("brc_flag?[OFF=0, SIGNAL=1, USMAIL=2]  ");
 *  scanf("%i",&brc_flag);
 */
  brc_flag = 0; /*----> not paticipate in Broadcasting <-----*/
  status = ddu_set_brc(brc_flag); 
  printf("\nusrdownload: ddu_set_brc = %d\n",status);
  fflush(stdout);
  
  /*---------->  Ntuple option  <-----------*/
  printf("\nDo you want to make a ntuple? (y or n) ");
  scanf("%c",&ntupleOk);
  if ( ntupleOk == 'y' || ntupleOk == 'Y' ) {
     system("$DD_BIN/dd_hbk &");
     printf("\n\n-------->> Now dd_hbk activated!\n\n");
   }
  else {
     printf("\n\n-------->> No ntuple output selected!\n\n");
   }

  status = ddu_get_free_buffers(); /* free buffer #? */
  if ( status <= 0) {
        fprintf(stderr,"usrdownload:No available free buffer.");
       }                                                      
  else{
        printf("usrdownload: number of free buffers = %d\n",status);
      }

  return status;   
}

int usrExit_()
{
}

int usrprestart_(int *run_nb, int *run_type) 
{
  char *p, fname[1024], command[1024];
  FILE *fp;
  int my_runnb;
  struct coda_event br_event;
  struct fifo_entry fev;          
  int status;
  time_t t;

  /*----> increase my_runnb by one and record it in MY_RUNNB file. <----*/
  if ( ( p = getenv("RCDATABASE") ) != NULL ){      
    sprintf(fname,"%s/MY_RUNNB",p);
    if ( (fp = fopen(fname,"r+") ) != NULL ){
      fscanf(fp,"%d",&my_runnb);
      rewind(fp);
      fprintf(fp,"%d",++my_runnb);
      fclose(fp);
    }
  }                 
  if ( status = ddu_req_fev(sizeof(struct coda_event)/4,&fev) ){
    fprintf(stderr,"usrPrestart: ddu_req_feq failed:%d\n",status);
  }
  else{
    fev.ctlw1 = PRESTART_EVENT;
    fev.ctlw2 = -1;
    fev.ctlb1 = -1;
    fev.ctlb2 = -1;            
    fev.len = 5;

    br_event.xwc = 4;
    br_event.flag = PRESTART_EVENT<<16 | 1<<8;

    br_event.buffer[0] = br_event.xwc;
    br_event.buffer[1] = br_event.flag;
    br_event.buffer[2] = (int) time(&t);
    br_event.buffer[3] = my_runnb;
    br_event.buffer[4] = *run_type;  

    memcpy(fev.p2da, &br_event.buffer, 4*(br_event.xwc+1) );
    if ( status = ddu_brc_fev(fev,2000) ){
          fprintf(stderr,"usrPrestart: ddu_brc_fev failed:%d\n",status);
	}
  }
  return status;
}

int usrend_()
{
  struct coda_event er_event;
  struct fifo_entry fev;
  int status;                      
  time_t t;

  if ( status = ddu_req_fev(sizeof(struct coda_event)/4,&fev) ){
    fprintf(stderr,"usEnd: ddu_req_feq failed:%d\n",status);
  }
  else{
    fev.ctlw1 = END_EVENT;
    fev.ctlw2 = -1;
    fev.ctlb1 = -1;
    fev.ctlb2 = -1;
    fev.len = 5;

    er_event.xwc = 4;
    er_event.flag = END_EVENT<<16 | 1<<8;
     
    er_event.buffer[0] = er_event.xwc;
    er_event.buffer[1] = er_event.flag;
    er_event.buffer[2] = (int) time(&t);
    er_event.buffer[3] = 0;
    er_event.buffer[4] = 0;         

    memcpy(fev.p2da, &er_event.buffer, 4*(er_event.xwc+1) );
    if ( status = ddu_brc_fev(fev,2000) ){
          fprintf(stderr,"usrEnd: ddu_brc_fev failed:%d\n",status);
         }
    }
  return status;
}

int usrevent_(int *buffer, int *buflen, int *flag)
{
  int status,i;
  struct data_event *my_event;
  struct fifo_entry fev;

  if ( status = ddu_req_fev(*buflen+4,&fev) ){
  /*-----> prepare a fifo_entry to receive an event <-----*/
    fprintf(stderr,"usrEvent: ddu_req_feq failed:%d\n",status);
  }         
  else{
    my_event = (struct data_event*) buffer;

    fev.ctlw1 = TEST_EVENT;
    fev.ctlw2 = -1;
    fev.ctlb1 = -1;
    fev.ctlb2 = -1;
    fev.len = *buflen + 1;
    
    memcpy(fev.p2da, my_event, 4* *buflen + 4); 
    if ( status = ddu_brc_fev(fev,1000) ){
    /*-----> coping event and broadcasting it over 
             the all dd processes ------*/
	fprintf(stderr,"usrEvent: ddu_brc_fev failed:%d\n",status);
      }

/*    if ( status = ddu_put_fev(fev) ){
 *      fprintf(stderr,"usrEvent: ddu_put_fev failed:%d\n",status);
 *     } 
 *     ---> put fev is not neccessary because brc fev automatically
 *          put fev directly into INPUT_FIFO 
 */

  }
  return status;
}
  

main ()
{
   atexit(clean);

   rcService(RC_SERVICE_EB);
   rcService(RC_SERVICE_ANA);
   rcExecute();

}