#include <stdio.h>
#include <stdlib.h>
#include "event.h"
#include "monitor.h"
#include "TPCDateIO.h"
#include "TPCRun.h"
#include <iostream>
//ClassImp(TPCDateIO);
TPCMapping *gTPCMapping;
TPCData *gTPCData;
TPCRun  *gRun;
	 
void TPCDateIO::printError( char *where, int errorCode ) {
  fprintf( stderr, "Error in %s: %s\n", where, monitorDecodeError( errorCode ) );
  exit( 1 );
} 

int TPCDateIO::PrintEquipmentHeader(struct equipmentHeaderStruct *e){
  fprintf(  stdout,"EQ size=%d type=%d id=%d ", e->equipmentSize, e->equipmentType, e->equipmentId);
  char *ptr=(char *) e;
  unsigned int * data =  (unsigned int *) (((struct equipmentStruct * )(ptr))->equipmentRawData);
  fprintf(stdout,"roi=0x%x trgcl=%d id=%d status=0x%x L1Trg=%d\n",
	  data[6],data[4],data[3]& 0xfff,(data[3]>>12)& 0x3ffff ,(data[1]>>16)&0xff );
  
  return 0;
}

int TPCDateIO::PrintEventHeader(struct eventHeaderStruct *event){
  fprintf(stdout,"EVN %5d size=%d SWAP=%d type=%d ldc=%d gdc=%d id:%d  ver=%d head=%d runNb=%d, data=%d\n",
	   fcnt++, 
	   event->eventSize,
	   event->eventMagic == EVENT_MAGIC_NUMBER_SWAPPED,
	   event->eventType,
	   event->eventLdcId,
	   event->eventGdcId,
	   EVENT_ID_GET_NB_IN_RUN(event->eventId),
	   event->eventVersion,
	   event->eventHeadSize,
	   event->eventRunNb,
	   event->eventSize - event->eventHeadSize);


 return 0;
}


int TPCDateIO::PrintAltroChannel(long long * x ){
  int TrailerWordHWAddr  =  (*x)&0xfff;
  int TrailerWordWCount  = ((*x)>>16)&0x3ff;
  int HWCAddr =             TrailerWordHWAddr&0x7f;
  TrailerWordHWAddr      =  TrailerWordHWAddr >> 7;
  fprintf(stdout,"HW %03d ch=%03d %03d\n", TrailerWordHWAddr, HWCAddr,TrailerWordWCount );
  return 0;
}

short TPCDateIO::get10BitWord(unsigned short * x, int pos) {
  return ( (*x) >> pos ) & 0x3ff;
}

int TPCDateIO::ProcessAltroChannel(unsigned char *ptr, int evn_version) {
  unsigned short fchanneltemp;

  long long *Trailer = ((long long *) (ptr-4));
  //PrintAltroChannel( Trailer );
  int TrailerWordHWAddr  =  (*Trailer)     &0xfff;
  int TrailerWordWCount  = ((*Trailer)>>16)&0x3ff;

  if (evn_version<196610) {
    // here there i find no distinction between channels hwaddr for channels from different branches
    static int oldfec=0;
    int fec=(TrailerWordHWAddr>>7);
    if (fec>oldfec && (firstfec!=1)) fbranch=1;
    oldfec=fec;
    firstfec=0;
    if (fbranch==1){
      (*Trailer) |=   0x800;
      TrailerWordHWAddr |=   0x800;
    }
  }
  
  gTPCData->AddChannel(TrailerWordHWAddr, (char *) ptr );

  return TrailerWordWCount/4+2;
// skip decoding
  ptr  -= 8; // skip trailer (5) + 3
  short wordShift = 6 - (TrailerWordWCount % 4)*2;



  for(int i = 0 ; i < TrailerWordWCount; i++){

    fchanneltemp          = get10BitWord( (unsigned short *) ptr, wordShift );

    wordShift-=2;
    ptr--;
    if( wordShift == -2) {
      wordShift = 6;
      ptr-- ;
    }

    fprintf(stdout,"%d ",fchanneltemp);
  }
  
  return TrailerWordWCount/4+2;
}

int TPCDateIO::ProcessEquipment(char *ptr, int evn_version){
  
  struct equipmentHeaderStruct * eheader= (struct equipmentHeaderStruct *) (ptr);

//  PrintEquipmentHeader(eheader);
  
  unsigned char * data       = (unsigned char *) (((struct equipmentStruct * )(ptr))->equipmentRawData);
  unsigned int * fmemory     = (unsigned int *) data;
  int  size            = eheader->equipmentSize;
  const int  hsize           = sizeof(struct equipmentHeaderStruct);
  switch (evn_version){  
  
  case 196609:
    //Equipment Size is WITHOUT the Header of the Equipment !! in the old Version ! + double hwaddr
    size = size + hsize;
    firstfec=1;
    fbranch=0;
    break;
  case 196610:
    eheader->equipmentId -= 2000;
    break;
  default:
    std::cout << "Check equipmentId Rcuid"<< std::endl;
    break; 

  }
  if (eheader->equipmentType!= 17) return size; // here it would come calls for different detectors  TOF/MST
  gTPCData->AddRcu(eheader->equipmentId, ptr );  
  const int  fsize           = (size-hsize)/4;
  int  f40BitArraySize = fmemory[fsize-1]; // last word of the equipment

  int n40BitWords = f40BitArraySize-1;
  const int offset=28;
  unsigned char *cptr =&data[f40BitArraySize*5+offset-1];// last data pointer	
  int k=0;
  while( n40BitWords >0){
    int wc = ProcessAltroChannel(cptr, evn_version); 
    n40BitWords -= wc;
    cptr-=5*wc;
    k++;
  };
//  fprintf(stdout,"AltroChannels %d\n", k);

  return size;
}

int TPCDateIO::ProcessEvent(char *ptr){
  char *eptr = ptr;
  struct eventHeaderStruct     * event    = (struct eventHeaderStruct *)     (ptr);
  int  esize  = event->eventSize;
  int  size   = esize;

  // skip header
  size   = event->eventHeadSize;
  eptr  += size;
  esize -= size;
  // PrintEventHeader(event); 
  gTPCData->SetEvent(ptr);
  if (event->eventType != PHYSICS_EVENT) return event->eventSize;
  while (esize>0){
    if(TEST_SYSTEM_ATTRIBUTE( event->eventTypeAttribute, ATTR_SUPER_EVENT ) == 1){
      size   = ProcessEvent(eptr);
    } else {
      size   = ProcessEquipment(eptr,event->eventVersion);
    }
    eptr  += size;
    esize -= size;
  }
  return event->eventSize;
}
 
	   	 
TPCDateIO::TPCDateIO(char *datefile, char *geopath) {
  int status;
  std::cout << "TPCDateIO::TPCDateIO(" << datefile << ","<< geopath<< ")" << std::endl;
  //  status = monitorSetDataSource( ":" );
  if (strlen(datefile)==0){
    fprintf(stderr,"Usage  TPCread <date file> <geopath>\n");
    fprintf(stderr,"TPCread /data2/run98.012.raw geo/2004/T10\n");
    exit(1);
  }

  status = monitorSetDataSource( datefile );
  if ( status != 0 ) printError( "monitorSetDataSource", status );
  std::cout << "monitorSetDataSource" << datefile<< std::endl;

  status = monitorDeclareMp( "C demo mp" );
  if ( status != 0 ) printError( "monitorDeclareMp", status );
  std::cout << "monitorDeclareMp" << std::endl;
  gTPCData = new TPCData(2,0xfff);   
  std::cout << "new TPCData" << std::endl;

  gTPCMapping = new TPCMapping(geopath);
  gRun = new TPCRun(gTPCMapping);
  std::cout <<"new TPCRun" << std::endl;
  gRun->StartOfRun( gTPCData );
  std::cout << "gRun->StartOfRun" << datefile<< std::endl;
} /* End of main */

TPCDateIO::~TPCDateIO(){
    gRun->EndOfRun( gTPCData );
    delete gRun;
    delete gTPCMapping;
}


//-----------------------------------------------------
int TPCDateIO::Process(int neve=1, int skip=0){
    int status=0,cnt=0;
    for (int i=0;i<neve;i++){
      if (!skip){
	gTPCData->Reset();
	gRun->StartOfEvent( gTPCData );
      }
      void *ptr;
      struct eventHeaderStruct *event;      
      status = monitorGetEventDynamic( &ptr );
      if ( status != 0 ) return -cnt;
      if (!skip){
	event = (struct eventHeaderStruct *)ptr;
	ProcessEvent((char *) ptr);
	gRun->EndOfEvent( gTPCData );
      }
      free( ptr );
      cnt++;
    }
    return cnt;

}