/*
read adc125 data with random trigger check if a channel is
over a given threshold and write those channels with all samples
to data file
*/

#include <iostream>
#include <fstream>

using namespace std;

extern "C"{
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <jvme.h>
#include <tiLib.h>
#include "f1NEWtdcLib.h"
#include "math.h"
#include "time.h"   
#include "sys/types.h"
  
  extern int nf1tdc;
  extern int f1NEWtdcA32Base;  
  extern int tiA32Base;
  extern int f1NEWAddrList[F1NEW_MAX_BOARDS]; 
  
  //DMA_MEM_ID vmeIN,vmeOUT;
  //extern DMANODE *the_event;
  //extern unsigned int *dma_dabufp;
  
}

UINT32 F1TDCData[40000];

#define TI_ADDR (21<<19)
#define F1TM_ADDR  0xe100
#define F1NEW_TIME_MASK         0x0000ffff

#define BLOCKLEVEL 1
int NTDCS = 1;
int TDC_SLOT_START = 3;
int TIMETEST = 0;

#define F1NEWTDC_BLOCK_MODE 0
int exCounter = 0;

ofstream OUTF;
ofstream OUTRAW;

void myReadoutCode();

unsigned int START;

int n;
int  main(int argc, char *argv[])  {

  int Nevents = 1000;
  int iFlag;
  int stat;
  char ofnam[128];
  char DataDir[128] = "/gluonraid1/Users/hdfdcops/fdcdata";
  
  char CrateName[128] = "One";
  char RawFName[128] = "rawdata.dat";
  
  printf("\nJLAB f125ADC pedestal Tests\n");
  printf("----------------------------\n");
  
  int k=0;

  if (argc<1 ) {
    cout<<"usage: pulserTestNew [Options]"<<endl;
    cout<<"       -S  #        Slot number of first TDC to be used in test (default 3)"<<endl;
    cout<<"       -N  #        Number of triggers default is 1000"<<endl;
    cout<<"       -A  #        All # TDCs from slot 3 to 3+# (default 1)"<<endl;
    cout<<"       -C  string   Crate Name (default \"One\")"<<endl;
    cout<<"       -TT          Timing Test" <<endl;
    cout<<"       -R  string   raw data to file \"string\""<<endl;
    return 0;
  }

  for (k=0;k<argc;k++){
    
    if (!strcmp(argv[k],"-S")){
      TDC_SLOT_START = atoi(argv[k+1]);
      k++;
    }
    
    if (!strcmp(argv[k],"-N")){
      Nevents = atoi(argv[k+1]);
      k++;
    }
    
    if (!strcmp(argv[k],"-A")){
      NTDCS = atoi(argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-C")){
      sprintf(CrateName,"%s",argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-TT")){
      TIMETEST = 1;
    }
    if (!strcmp(argv[k],"-R")){
      sprintf(RawFName,"%s",argv[k+1]);
      k++;
      OUTRAW.open(RawFName,ios::out);
      OUTRAW<<hex;
    }

    if (!strcmp(argv[k],"-h")){
      cout<<"usage: pulserTestNew [Options]"<<endl;
      cout<<"       -S  #        Slot number of first TDC to be used in test (default 3)"<<endl;
      cout<<"       -N  #        Number of triggers default is 1000"<<endl;
      cout<<"       -A  #        All # ADCs from slot 3 to 3+# (default 1)"<<endl;
      cout<<"       -C  string   Crate Name (default \"One\")"<<endl;
      cout<<"       -TT          Timing Test" <<endl;
      cout<<"       -R  string   raw data to file \"string\""<<endl;
      return 0;
    }
    
  }

  if (NTDCS==1){
    sprintf(ofnam,"%s/tdcdata_%s_slot%d.dat",DataDir,CrateName,TDC_SLOT_START); 
  } else {
    sprintf(ofnam,"%s/tdcdata_%s_ALLslots.dat",DataDir,CrateName); 
  }

  if(vmeOpenDefaultWindows() != OK) {
    cout<<"vmeOpenDefaultWindows failed. Terminate right here."<<endl;
  } else {// vmeOpenDefaultWindows

    //vmeDmaConfig(2,5,1);
    /* INIT dmaPList */
    
    //dmaPFreeAll();
    //vmeIN  = dmaPCreate("vmeIN",20244,100,0);
    //vmeOUT = dmaPCreate("vmeOUT",0,0,0);
    //dmaPStatsAll();
    //dmaPReInitAll();
    
    
    tiInit(TI_ADDR, TI_READOUT_EXT_POLL, 0);
    tiCheckAddresses();
    tiDisableDataReadout();
    tiDisableA32();
    //tiSetClockSource(0);
    
    tiLoadTriggerTable(0);
    tiSetTriggerHoldoff(1,4,0);
    tiSetTriggerHoldoff(2,4,0);
    tiSetPrescale(0);
    tiSetBlockLevel(1);
    
    tiSetTriggerSource(TI_TRIGGER_PULSER);
    tiEnableTSInput(0x1);

    // this is only for NOW!!!!!!!!!!!!! to overcome ROC4 problem
    tiSetBusySource(TI_BUSY_LOOPBACK, 1);

    tiSetBlockBufferLevel(1);
    // tiSetFiberDelay(1,2);
    // tiSetSyncDelayWidth(1, 0x3f, 1);
    
    // setup clock, etc for single-crate system only
    tiClockReset();
    taskDelay(1);
    tiTrigLinkReset();
    taskDelay(1);
    tiEnableVXSSignals();
    taskDelay(1);
    tiSyncReset();
    taskDelay(1);
    tiStatus();
    tiSetOutputPort(1, 0, 0, 0);
    // tiClockResync();
    // tiClockReset();
    // tiSyncReset();
    
    // initialize the TDCs

    for (int k=0; k<NTDCS; k++){
      int slot = k + TDC_SLOT_START;
      f1NEWAddrList[k] = slot<<19;
      if (slot>10){
	slot += 2;
	f1NEWAddrList[k] = slot<<19;
      }
    }

    f1NEWConfigReadFile("./newf1config_lat1400_win1300.dat");

    iFlag  = (1<<17); /* use f1NEWAddrList */
    //iFlag  = 0; /* use f1NEWAddrList */
    iFlag |= F1NEW_TRIGSRC_VXS;  /* Trigger Source */
    iFlag |= F1NEW_CLKSRC_VXS;  /* Clock Source */
    iFlag |= F1NEW_SRSRC_VXS; /* sync source*/

    //cout<<"Number of TDCS "<<NTDCS<<"  "<<hex<<f1NEWAddrList[0]<<endl;
    stat = f1NEWInit(0x180000, 0, NTDCS, iFlag);

    if (stat != OK) {
      cout<<"ERROR: f1NEWInit failed, stop right here!!!"<<endl;
      return 0;
    } 
    
    // Init SD
    sdInit();
    printf("************************************************************\n");
    printf(" MASK = x0x%08x\n",f1NEWScanMask());
    printf("************************************************************\n");
    sdSetActiveVmeSlots(f1NEWScanMask());
    //  sdSetActiveVmeSlots(1<<TDC_SLOT_START ); 
    sdStatus();


    f1NEWGSetBlockLevel(BLOCKLEVEL);
    f1NEWGStatus(0);
    f1NEWGEnableBusError();

    tiIntConnect(TI_INT_VEC,myReadoutCode,0);
    n = 0;

    printf("Hit return to start Triggers...\n");
    getchar();
      
    f1NEWGEnableData(0);
    f1NEWGEnable();

    /* Enable the TI and clear the trigger counter */
    tiIntEnable(0);
    tiStatus();
      
    if (!TIMETEST){
      OUTF.open(ofnam,ios::out);
    }

    cout<<clock()<<"   START OF LOOP"<<endl; 
    START = clock();

    tiSetRandomTrigger(1,0x7);

    while (tiGetIntCount()<Nevents){

      
    }// end of loop overall events
    cout << "   <Enter> to exit"<<endl; 

    tiIntDisable();
    tiIntDisconnect(); 

    f1NEWStatus(0,0);

    f1NEWGDisable();

    if (!TIMETEST){
      OUTF.close();
    }

    if (OUTRAW){
      OUTRAW.close();
    }

    cout<<clock()<<"    END OF LOOP"<<endl;    
    unsigned int ENDL = clock();
    
    //tiIntDisable();
    cout<<"TOTAL TIME: "<<(ENDL-START)/CLOCKS_PER_SEC<<" seconds"<<endl;
   
  }

  vmeCloseDefaultWindows();      

  return 0;
}

//!!!!!!!!!!!!!!!!!

void myReadoutCode(){
  
  UINT32 tdcData[18432]; // maximum of 15 TDCs with 64 channels each
  int MAXTDC = 1024;
  UINT32 *dp;
  dp = tdcData;
  //cout <<"huh" << endl;
  int Counter = 0;

  int HitCounter[20];
  int Hits[20][500];
  memset(HitCounter,0,80);

  for (int k=0;k<NTDCS;k++){
    int S = TDC_SLOT_START + k;
    if (S>10){
      S +=2;
    }
    int nhits = f1NEWDready(S);
    dp = tdcData;
    if( (nhits<MAXTDC) && (nhits>0) ) {
      int nwords = f1NEWReadBlock(S, dp, MAXTDC,0);

      for (int i=0;i<nwords;i++){
	unsigned int data = (unsigned int)LSWAP(*dp);
	if (( (data>>27)&0x1f) == 0x17){ 
	  int chip = (data>>19 & 0x7);
	  int chan = (data>>16 & 0x7);
	  int T_chan = chip*8 + chan;
	  int time = (data & 0xFFFF);
	  OUTF<<n<<" "<<k<<" "<<T_chan<<" "<<time<<endl; 
	}

	if (OUTRAW){
	  OUTRAW<<data<<" ";
	}

	dp++;

      }
      if (OUTRAW){
	OUTRAW<<endl;
      }
      
    }
    
  }

  n++;

  if (!(n%10000)){
    cout<<(clock()-START)/CLOCKS_PER_SEC<<" s   :"<<n<<endl;
    START = clock();
  }

}