#include "mdaq.h" 
#include <utility.h>
#include <cvirte.h>		
#include <userint.h>
#include <ansi_c.h> 
#include <errno.h>
#include "gui.h"

//#define USE_MIKRO
#define USE_DAC

#ifdef USE_MIKRO
#include "MIKRO.h"
#define MIKRO_COM 5
#endif

	 
#define MAX_THREADS 10 
static int poolHandle = 0; 
static int panelHandle,tfID, dummy;


#define MAXCH 32
#define NCH MAXCH
#define ADCRANGE 0x1000	 
unsigned int adcdata[2][MAXCH][ADCRANGE];
unsigned int datadc[ADCRANGE];

#define TDCRANGE 0x10000
unsigned int tdcdata[2][MAXCH][TDCRANGE];
unsigned int dattdc[TDCRANGE];

#define MAXSIZE ADCRANGE
typedef struct {
int recid;
int size;
int time;
int id;
int nbins;
char name[120];
float xmin;
float xmax;
float data[MAXSIZE];
} TH1F;

TH1F tch[2*MAXCH];

#define HISTREC_ID 11

int TH1Finit(int id, char *hname, int nbins, float xmin, float xmax){
  tch[id].recid= HISTREC_ID;
  tch[id].id=id;
  tch[id].time=time(NULL);
  if (nbins>MAXSIZE) nbins=MAXSIZE;
  sprintf(tch[id].name,"%s",hname);
  tch[id].nbins= nbins; 
  tch[id].xmin = xmin;
  tch[id].xmax = xmax;
  tch[id].size = sizeof(TH1F) - (MAXSIZE - nbins)* sizeof(float);
  return 0;
}

int TH1Freset(int id){
  int i;
  tch[id].time=time(NULL);
  for (i=0;i<tch[id].nbins;i++) tch[id].data[i]=0;
  return 0;
}

unsigned long hextoul(char* str)
{
unsigned long retval;
unsigned int digit;

retval=0;
while(*str)
{
if((*str>='0')&&(*str<='9'))
digit=*str-'0';
else
if((*str>='a')&&(*str<='f'))
digit=*str-'a'+10;
else
if((*str>='A')&&(*str<='F'))
digit=*str-'A'+10;
else
break;
if(retval>0xFFFFFFF)
{
// Overflow - you need to decide what to do!
}
else
retval=retval*16+digit;
str++;
}
return(retval);
}

int daq_on=0;
void UIRDimming(int pnl,int flag)
{
 
     SetInputMode (pnl, P_START, flag);
     SetInputMode (pnl, P_EXIT, flag); 
     SetInputMode (pnl, P_STOP ,!flag); 
     
}
  	 
int hfill(unsigned long *x, int len){

int recid,  reclen, i,j, edge, ch, rg, val;
unsigned int data;

//printf("len=%d\n",len);
i=0;
while (i<len){

recid =x[i++];
reclen=x[i++];
//printf("recid 0x%08x reclen=%d len=%d\n",recid, reclen,len);

for (j=0;j<reclen;j++){
   if (i<len)    data=x[i++];     
   else break;

switch (recid) {
case 12:
     
	    val =   data &0xFFFF;		       
        ch  =  (data  >> 17 ) &0x1F;               	  	
        edge = (data  >> 16 ) &0x1;
        tdcdata[edge][ch][val]++;
	  //  printf("%d [%d] %d  data=%d\n",j,ch,edge,val);
break;

case 0x340000:
case 0x550000:

                  edge=(data>>25)&0x3;
		     	  if (edge==0) {
		     	    ch=(data>>17)&0xf;
		     	    if (recid==0x550000) ch+=16;
		     	    rg=(data>>16)&0x1;
		     	    val=data&0xfff;
		     	   // printf("%d [%d] %d  data=%d\n",j,ch,rg,val);
			 	    adcdata[rg][ch][val]+=1;
			 	    tch[ch+rg*MAXCH].data[val]++;
		     	   
		     	  }
    
break;
case 0x330000: 
	if (((data>>27)&0x1F)==0){
	      
	    edge  = (data >> 26 ) & 0x1;
	    ch    = (data >> 21 ) & 0x1F;
	    val   =   data & 0x1FFFFF;
	    tdcdata[edge][ch][val/40]++;   
	     //printf("%d [%d] %d  data=%d\n",j,ch,edge,val);
	}
break;
default:
printf("Error in buffer\n");

}

} 

}


return 0;
}  	 

int reset_histo(){
int rg, i, ch;
 for (rg=0;rg<2;rg++){
    for (ch=0;ch<MAXCH;ch++){
       for (i=0;i< ADCRANGE;i++) adcdata[rg][ch][i]=0;
       for (i=0;i< TDCRANGE;i++) tdcdata[rg][ch][i]=0; 
       TH1Freset(ch+rg*MAXCH);
    }
  }
  return 0;
}  
    	 
int CVICALLBACK daq(void *functionData){ 	 

#define BSIZE 20000
  unsigned long data[BSIZE];
  FILE *fp;	
  int pedestal;
  int neve=-1;
  char fname[128], hname[120];
  int status;
  int writerawdata=1,gatetime=1;
   // print welcome message
  time_t t;

  #define RUNREC_ID 1
  #define ENDREC_ID 2
  #define POSREC_ID 3
  #define EVTREC_ID 4
  #define DACREC_ID 5

unsigned int hdr[4]={EVTREC_ID};//recid
  int i,ch,rg;
  int ntotal=0;
  
  int nb=0,nb1=0;
  int counters[10]={0,0,0,0,0,0,0,0,0,0};
  
  int flag,istdc,isadc;
  unsigned int mask[2];
  unsigned long imask;
  char strmask[128];
  
  typedef struct {
    unsigned long id,len;
    unsigned long fver,time;
    unsigned long nev,nch,ped,xy;
    long nx,x0,dx,ny,y0,dy;
    } RUNREC;
	RUNREC runrec;
	
  typedef struct {
    unsigned long id,len;
    unsigned long time;
    } ENDREC;
	ENDREC endrec;

   typedef struct {
    unsigned long id,len;
    float dac;
     float dac0;  
     float dac1;
     float ddac;  
    } DACREC;
	DACREC dacrec;	
	
	
	
  typedef struct {
    unsigned long id,len;
    unsigned long time;
    long ix,x,xset,iy,y,yset;
    } POSREC;
	POSREC posrec;

  typedef struct {
    unsigned long id,len;
    unsigned long nev;
    unsigned short data[NCH*2];
    } EVTREC;
	EVTREC evtrec;
	
	runrec.id = RUNREC_ID;
	runrec.len = sizeof(runrec);
	runrec.fver = 0x10000;
	runrec.nch = NCH;
	runrec.xy = 1;

	endrec.id = ENDREC_ID;
	endrec.len = sizeof(endrec);

	posrec.id = POSREC_ID;
	posrec.len = sizeof(posrec);

	evtrec.id = EVTREC_ID;
	evtrec.len = sizeof(evtrec);
	
    dacrec.id = DACREC_ID;
	dacrec.len = sizeof(dacrec);
  
  
  time(&t);

  GetCtrlVal(panelHandle, P_NEVE, &neve);
  GetCtrlVal(panelHandle, P_NEVE, &runrec.nev);
  GetCtrlVal(panelHandle, P_FNAME, fname);  
  GetCtrlVal(panelHandle, P_EVENTOUTPUT, &writerawdata);
  GetCtrlVal(panelHandle, P_GATETIME, &gatetime);   


  daq_on=1; 
 
  fp=fopen(fname,"wb");

  fprintf(stdout,"#############################################\n");
  fprintf(stdout,"Program daqpet \n");
  fprintf(stdout,"Compiled on %s %s\n",__DATE__, __TIME__);
  fprintf(stdout,"Runtime  %s \n",ctime(&t));
  fprintf(stdout,"#############################################\n");
  
  GetCtrlVal (panelHandle, P_PEDESTAL, &runrec.ped); 
  GetCtrlVal(panelHandle, P_PEDESTAL, &pedestal);
  GetCtrlVal(panelHandle, P_MASK, strmask);
  imask= hextoul(strmask);
  
  mask[0]=imask & 0xFFFF;
  mask[1]=(imask>>16) & 0xFFFF;
  printf("------->  %s 0x%x mask=0x%x  0x%x\n", strmask, imask, mask[0], mask[1]); 


  for (i=0;i<MAXCH;i++) if ( (0x1<<i) & imask ) {
  	  sprintf(hname,"ch0%02d", i);      
      TH1Finit(i,hname,4096,-0.5, 4095.5); 
      sprintf(hname,"ch1%02d", i);      
      TH1Finit(i+MAXCH,hname,4096,-0.5, 4095.5);
  }
   
   
  init(pedestal,mask,gatetime);
  clear();
  
#ifdef USE_MIKRO
      GetCtrlVal (panelHandle, P_NX, &runrec.nx);
	GetCtrlVal (panelHandle, P_XSTEP, &runrec.dx);
	GetCtrlVal (panelHandle, P_XMIN, &runrec.x0);
	GetCtrlVal (panelHandle, P_NY, &runrec.ny);
	GetCtrlVal (panelHandle, P_YSTEP, &runrec.dy);
	GetCtrlVal (panelHandle, P_YMIN, &runrec.y0);
	  status = fwrite (&runrec, 1, runrec.len, fp);

	  for (posrec.ix=0;posrec.ix<runrec.nx;posrec.ix++) {
	  posrec.xset=runrec.x0+posrec.ix*runrec.dx;

	  MIKRO_MoveTo (1, posrec.xset);
	  SetCtrlVal (panelHandle, P_X, posrec.xset);
	  SetCtrlVal (panelHandle, P_IX, posrec.ix);

		  for (posrec.iy=0;posrec.iy<runrec.ny;posrec.iy++) {
        posrec.yset=runrec.y0+posrec.iy*runrec.dy;

	    MIKRO_MoveTo (2, posrec.yset);
	    SetCtrlVal (panelHandle, P_Y, posrec.yset);
	    SetCtrlVal (panelHandle, P_IY, posrec.iy);
	    time (&posrec.time);
	    status = fwrite (&posrec, 1, posrec.len, fp);
    
#endif

#ifdef USE_DAC
    GetCtrlVal (panelHandle, P_DAC0, &dacrec.dac0); 
    GetCtrlVal (panelHandle, P_DAC1, &dacrec.dac1);
    GetCtrlVal (panelHandle, P_DDAC, &dacrec.ddac); 
    
    		
    for (dacrec.dac=dacrec.dac0;dacrec.dac<dacrec.dac1;	dacrec.dac+= dacrec.ddac ) {
	    SetDac (4096*dacrec.dac/10.);
	    SetCtrlVal (panelHandle, P_DAC, dacrec.dac);  
	    status = fwrite (&dacrec, 1, dacrec.len, fp);
#endif
  reset_histo();  
  GetCtrlVal (panelHandle, P_ISTDC, &istdc);  
  GetCtrlVal (panelHandle, P_ISADC, &isadc);  
  flag= (istdc << 1) |isadc;
  for (i=0;i!=neve && !fStop;i++){     
     time(&t);
     
     nb=event(flag,data,BSIZE, counters,mask);
     
     if (!(i%100))SetCtrlVal(panelHandle, P_CEVE, i); 
     
     if (nb>0){
      // zapis v datoteko   
      hdr[1]=nb+4*sizeof(int);
      hdr[2]=time(NULL);
      hdr[3]=i;
      //printf("Event %d %d %d %d  nb=%d %d\n",hdr[0],hdr[1],hdr[2],hdr[3],nb,nb/4); 
	  if (writerawdata){
        fwrite(hdr,   sizeof(int),4 , fp);
        nb1=fwrite(data, 1,nb, fp);
        if (nb1!=nb) printf("IO error %d != %d err=%d %s\n\n\n\n",nb1,nb, errno, strerror(errno) );
      }  
      ntotal += nb1;
      hfill(data,nb/sizeof(int));
     } else {
       i--;
       printf("%d daq::event() Tout %s nb=%d\n",i,ctime(&t),nb);
     }  
  } 
  
  for (i=0;i<MAXCH;i++) if ( (0x1<<i) & imask ) {
    printf("TH1write channel %d size=%d\n",i,tch[i].size);
    fwrite( &tch[i],tch[i].size,1, fp);
    fwrite( &tch[i+MAXCH],tch[i+MAXCH].size,1, fp);     
  }
#ifdef USE_DAC
	   if (fStop) break;
	  }
#endif
  
#ifdef USE_MIKRO
      
      if (fStop) break;
	  }

	  if (fStop) break;
	 }
#endif  

  end();
 
  printf("Number of Events: %d\n",i);
  if (fStop) printf("User Program termination CTRL-C\n");
  
  daq_on=0;
  fclose(fp);  
  fprintf(stdout,"%d bytes written to %s\nCounts:\n", ntotal*sizeof(int),fname);
  UIRDimming(panelHandle,1);
  return 0;
}


int update_plots (void)
{
  int adcch,tdcch,range,edge, i, ir,tdc, status=0, cureve=0;
  int alogy,tlogy;
  double fadcmax,ftdcmax;
  int fadcrebin, ftdcrebin , mode=0;
  double adcmax=0,tdcmax=0;
  double adcmin=0,tdcmin=0; 
  int adcrebin=1, tdcrebin=1;
  
  float rate=0;
  static int preveve=0, prevtime=0,curtime;
  
  
  
  GetCtrlVal (panelHandle, P_ADCCH, &adcch);
  GetCtrlVal (panelHandle, P_TDCCH, &tdcch);  
  GetCtrlVal (panelHandle, P_EDGE, &edge);
  GetCtrlVal (panelHandle, P_RANGE, &range); 
  GetCtrlVal (panelHandle, P_ADCLOGY, &alogy ) ; 
  GetCtrlVal (panelHandle, P_TDCLOGY, &tlogy ) ; 
  GetCtrlVal (panelHandle, P_CEVE, &cureve ) ; 
  time (&curtime);
  
  SetCtrlAttribute (panelHandle, P_ADC, ATTR_YMAP_MODE, alogy);
  SetCtrlAttribute (panelHandle, P_TDC, ATTR_YMAP_MODE, tlogy);
  
  //---------------------------------------- rebinning and setting the max
  GetCtrlVal (panelHandle, P_REBIN1, &fadcrebin);
  GetCtrlVal (panelHandle, P_REBIN2, &ftdcrebin);
  
  GetCtrlVal (panelHandle, P_MAX1, &fadcmax);
  GetCtrlVal (panelHandle, P_MAX2, &ftdcmax);
  fadcmax/=100.;
  ftdcmax/=100.;
  
  for (i=0;i< fadcrebin;i++) adcrebin*=2;
  for (i=0;i< ftdcrebin;i++) tdcrebin*=2;
  
  for (i=0;i< ADCRANGE/adcrebin;i++) if (datadc[i]>adcmax) datadc[i]=0; 
  for (i=0;i< TDCRANGE/tdcrebin;i++) if (dattdc[i]>tdcmax) dattdc[i]=0;
  
  for (i=0;i< ADCRANGE;i++) datadc[i/adcrebin]+=adcdata[range][adcch][i];
  for (i=0;i< TDCRANGE;i++) dattdc[i/tdcrebin]+=tdcdata[edge][tdcch][i]; 
  
  adcmax=0;
  tdcmax=0;
  for (i=0;i< ADCRANGE/adcrebin;i++) if (datadc[i]>adcmax) adcmax=datadc[i]; 
  for (i=0;i< TDCRANGE/tdcrebin;i++) if (dattdc[i]>tdcmax) tdcmax=dattdc[i];
  
  if (alogy) fadcmax=exp(fadcmax);
  if (tlogy) ftdcmax=exp(ftdcmax);
  
  adcmax *= fadcmax;
  tdcmax *= ftdcmax;
  if (adcmax==0) adcmax=1;
  if (tdcmax==0) tdcmax=1;
  
      
  
  SetAxisScalingMode (panelHandle, P_ADC, VAL_LEFT_YAXIS, VAL_MANUAL, 0.1, adcmax);
  SetAxisScalingMode (panelHandle, P_TDC, VAL_LEFT_YAXIS, VAL_MANUAL, 0.1, tdcmax); 
  
  GetAxisScalingMode (panelHandle, P_ADC, VAL_XAXIS, &mode, &adcmin, & adcmax);
  GetAxisScalingMode (panelHandle, P_TDC, VAL_XAXIS, &mode, &tdcmin, & tdcmax);
  
 // SetAxisScalingMode (panelHandle, P_ADC, VAL_XAXIS, VAL_MANUAL, 0.0, ADCRANGE/adcrebin);
 // SetAxisScalingMode (panelHandle, P_TDC, VAL_XAXIS, VAL_MANUAL, 0.0, TDCRANGE/tdcrebin); 
 //------------------------------------------------------------------------
  
  DeleteGraphPlot (panelHandle, P_ADC, -1, VAL_DELAYED_DRAW);
  PlotY (panelHandle, P_ADC, &datadc[0], ADCRANGE/adcrebin, VAL_UNSIGNED_INTEGER,
		 VAL_VERTICAL_BAR, VAL_SIMPLE_DOT, VAL_SOLID, 1, VAL_RED);
  
  DeleteGraphPlot (panelHandle, P_TDC, -1, VAL_DELAYED_DRAW);
  PlotY (panelHandle, P_TDC, &dattdc[0], TDCRANGE/tdcrebin, VAL_UNSIGNED_INTEGER,
		 VAL_VERTICAL_BAR, VAL_SIMPLE_DOT, VAL_SOLID, 1, VAL_RED);
  
 
 
  return (0);
}




int main (int argc, char *argv[])
{
	if (InitCVIRTE (0, argv, 0) == 0)
		return -1;	/* out of memory */
	if ((panelHandle = LoadPanel (0, "gui.uir", P)) < 0)
		return -1;
  
  SetStdioWindowOptions (1000, 0, 0);
  SetStdioWindowSize (300, 600);
  SetStdioWindowPosition (650, 15);
  reset_histo();
  daqconnect(); 		
#ifdef USE_MIKRO
  MIKRO_Open (MIKRO_COM);
  MIKRO_Init (1,0);
  MIKRO_Init (2,0);
#endif
		
  SetSleepPolicy(VAL_SLEEP_MORE);
  CmtNewThreadPool (MAX_THREADS, &poolHandle);

  
	DisplayPanel (panelHandle);
	RunUserInterface ();
	DiscardPanel (panelHandle);
#ifdef USE_MIKRO
  MIKRO_Close ();
#endif


    daqdisconnect();

	return 0;
}

int CVICALLBACK StopCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			
		fStop=1;
		  UIRDimming(panel,fStop);
			break;
		}
	return 0;
}

int CVICALLBACK StartCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
    int err;
	switch (event)
		{
		case EVENT_COMMIT:
			  
			  fStop=0;
			    UIRDimming(panel,fStop);
			 
			 err = CmtScheduleThreadPoolFunction (poolHandle, daq, (void *)&dummy,
												  &tfID);
			printf("Err %d!",err);
			break;
		}
	return 0;
}

int CVICALLBACK ExitCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			QuitUserInterface (0);
			break;
		}
	return 0;
}

int CVICALLBACK UpdateCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
    int fupdate=0;
	switch (event)
		{
		case EVENT_COMMIT:
			 update_plots(); 
		case EVENT_TIMER_TICK:
		    if (daq_on) {
		      GetCtrlVal(panelHandle, P_UPDATE, &fupdate);
		      if (fupdate) update_plots();
		    }  
			break;
		}
	return 0;
}

int CVICALLBACK ClearCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			reset_histo();
			break;
		}
	return 0;
}




int CVICALLBACK DacCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
  float voltage;
  int dac;
	switch (event)
		{
		case EVENT_COMMIT:
			GetCtrlVal (panelHandle, P_DAC, &voltage);
			dac=4096*voltage/10.; // 10V range
			SetDac(dac);
			break;
		}
	return 0;
}

int CVICALLBACK PrintCB (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	switch (event)
		{
		case EVENT_COMMIT:
			 PrintPanel (panel, "", 1, VAL_FULL_PANEL, 1);

			break;
		}
	return 0;
}