#include "TKLugIOVF.hh"

#include "TKLDataObject.hh"
#include "TKLTrack.hh"

#include <TString.h>

const Int_t kVFLowEnergyEventSize = 40; // bytes
const Int_t kVFMuonEventSize = 48; // bytes

ClassImp(TKLugReaderVF)
////////////////////////////////////////////////////////////////////////
//
// $Id: TKLugIOVF.cc,v 1.4 2002/10/25 01:10:43 kamland0 Exp $
//
// Interface to the vector-file format, used by the RCNS analysis group 
//
// Author: Patrick Decowski
//

 TKLugReaderVF::TKLugReaderVF(const char *filename)
  : fCheckEventNumber(kFALSE), fCheckTimeStamp(kFALSE), 
  fCheckTriggerType(kFALSE), fBuffer(0)
{
  // normal constructor
  Open(filename);
}

 TKLugReaderVF::~TKLugReaderVF()
{
  Close();
}

 Bool_t TKLugReaderVF::Open(const char *filename)
{
  // Open a vector-file file
  // Files with extension .lvf or .cvf are 'LowEnergy' vector-files
  // Files with extension .mvf are 'Muon' vector-files
  // (the events in these files have different sizes and therefore don't
  // mix). 

  TString f(filename);
  if(f.EndsWith(".mvf")) {
    fFileType = kMuonFile;
    fEventSize = kVFMuonEventSize;
  } else {
    fFileType = kLowEnergyFile;
    fEventSize = kVFLowEnergyEventSize;
  }
  fBuffer = new char[fEventSize];

  fFD = new ifstream(filename);  
  if(fFD)
    return fFD->is_open();
  else
    return kFALSE;
}

 void TKLugReaderVF::Close()
{
  // Close file
  fFD->close();
  delete fFD;
  delete[] fBuffer;
  fBuffer = 0;
}

 Bool_t TKLugReaderVF::IsOpen()
{
  // Return kTRUE if file is open
  return fFD->is_open();
}

 void TKLugReaderVF::Seek(Int_t entry)
{
  // Seek to an entry in the file (counted from the beginning)
  fFD->seekg(fEventSize * entry, ios::beg);
}

 Int_t TKLugReaderVF::Tell()
{
  // return the current entry
  return fFD->tellg() / fEventSize;
}

 Int_t TKLugReaderVF::ReadEvent(TKLEvent *evtptr)
{
  // Read one event from the vector-file

  if(fFD->eof())
    return kFail;

  Int_t ret = kFail;

  switch(fFileType) {
  case kLowEnergyFile:
    ret = ReadLowEnergyEvent(evtptr);
    break;
  case kMuonFile:
    ret = ReadMuonEvent(evtptr);
    break;
  default:
    Error("ReadEvent", "Unknown filetype");
  }
  return ret;
}

 Int_t TKLugReaderVF::ReadLowEnergyEvent(TKLEvent *evtptr)
{
  // Read a low energy event from a file

  fFD->read(fBuffer, fEventSize);
  
  // This is a direct copy from KVFLowEnergyEvent.hh
  // 8byte
  short                  RunNumber; // 16bit
  unsigned long long int TimeStamp; // 48bit

  // 8byte
  unsigned int           UnixTime; // 32bit
  int                    EventNumber; // 32bit

  // 8byte
  int                    PID; // 7bit
  float                  Energy; // 17bit
  int                    EventStatus; // 4bit
  unsigned long long int TriggerType; // 36bit

  // 8byte
  float  TotalChargeID; // 32bit
  float  TotalChargeOD; // 32bit

  // 8byte
  //  float  X; // 11bit
  //  float  Y; // 11bit
  //  float  Z; // 11bit

  Float_t X[4];
  unsigned int    N100; // 11bit
  unsigned int    NhitID; // 11bit
  unsigned int    NhitOD; // 8bit

  unsigned long long int L = 0;

  Int_t offset = 0;

  // In the following data fields that are labeled 'NA' don't have 
  // an equivalent (yet?) in AKat... 
  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  RunNumber = (short)( (L >> 48) & 0x0FFFF );
  unsigned long long int HigherTimeStamp 
    = (unsigned long long int)( (L >> 32) & 0x0FFFF );
  unsigned long long int LowerTimeStamp 
    = (unsigned long long int)( L & 0x0FFFFFFFF );
  TimeStamp = (HigherTimeStamp << 32) + LowerTimeStamp;

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  EventNumber = (int)( L & 0x0FFFFFFFF );
  UnixTime = (unsigned int)( (L >> 32) & 0x0FFFFFFFF ); // NA
  
  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  PID = (int)( (L>>60) & 0x0F ); // NA
  Energy = (float)( ( (unsigned int)( (L >> 40) & 0x0FFFFF ) )/5000.0 );
  //  EventStatus = (int)( (L >> 40) & 0x0F );
  EventStatus = (int)( (L >> 36) & 0x0F );
  unsigned long long int HigherTriggerType = (unsigned int)( (L >> 32) & 0x0F );  TriggerType = ( (HigherTriggerType << 32) | ( L & 0x0FFFFFFFF ) );
  
  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  TotalChargeOD = (float)( (L >> 32) & 0x0FFFFFFFF )/100.0; // NA
  TotalChargeID = (float)( L & 0x0FFFFFFFF )/100.0; // NA

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  X[0] = (float)( (int)((L >> 52) & 0x07FF) - 1024);
  X[1] = (float)( (int)((L >> 41) & 0x07FF) - 1024);
  X[2] = (float)( (int)((L >> 30) & 0x07FF) - 1024);
  X[3] = 0; // T in TKLVertex
  N100 = (unsigned int)( (L >> 19) & 0x07FF ); // NA
  NhitID = (unsigned int)( (L >> 8) & 0x07FF ); // NA
  NhitOD = (unsigned int)( L  & 0x0FF ); // NA

  //  Energy /= (KVFConstHandler::RunDependenceOfVisibleEnergy(RunNumber));

  // FIXME: is this it??
  evtptr->fEventHeader.fRunNumber = RunNumber;
  evtptr->fEventHeader.fEventNumber = EventNumber;
  evtptr->fEventHeader.fTimeStamp = Double_t(TimeStamp);
  evtptr->fEventHeader.fTriggerType = TriggerType;
  evtptr->fEventHeader.fStatus = EventStatus;
  
  for(Int_t i = 0; i < 3; i++)
    X[i] *= 10; // cm -> mm 

  TKLVertex *vtx = evtptr->GimmeVertex("vector_vtx");
  vtx->SetXYZT(X);
  vtx->SetEnergy(Energy);
  // Exclude bad events
  if((vtx->GetX() == 0 && vtx->GetY() == 0 && vtx->GetZ() == 0)
     || vtx->GetX() < -9000 && vtx->GetY() < -9000) 
    vtx->SetStatus(TKLVertex::kBadFitVertex);
  else
    vtx->SetStatus(TKLVertex::kValidVertex);

  return kHasEventData;
}

 Int_t TKLugReaderVF::ReadMuonEvent(TKLEvent *evtptr)
{
  // Read a muon event
  // 
  fFD->read(fBuffer, fEventSize);

  // 8byte
  short                  RunNumber; // 16bit
  unsigned long long int TimeStamp; // 64bit

  // 8byte
  unsigned int           UnixTime; // 32bit
  int                    EventNumber; // 32bit


  // 8byte
  unsigned int           Nhit5inch; // 3bit
  unsigned int           NhitOD; // 8bit
  unsigned int           NhitID; // 11bit
  int                    EventStatus; // 4bit
  unsigned long long int TriggerType; // 36bit

  // 8byte
  //  float                  EntranceX; // 11bit
  //  float                  EntranceY; // 11bit
  //  float                  EntranceZ; // 11bit
  float                  TotalChargeID; // 31bit

  // 8byte
  unsigned int           Badness; // 28bit
  float                  DirectionX; // 12bit
  float                  DirectionY; // 12bit
  float                  DirectionZ; // 12bit

  // 8byte
  float  TotalCharge5inch; // 32bit
  float  TotalChargeOD; // 32bit

  Int_t offset=0;
  unsigned long long int L = 0;

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  RunNumber = (short)( (L >> 48) & 0x0FFFF );
  unsigned long long int HigherTimeStamp 
    = (unsigned long long int)( (L >> 32) & 0x0FFFF );
  unsigned long long int LowerTimeStamp 
    = (unsigned long long int)( L & 0x0FFFFFFFF );
  TimeStamp = (HigherTimeStamp << 32) + LowerTimeStamp;

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  EventNumber = (int)( L & 0x0FFFFFFFF );
  UnixTime = (unsigned int)( (L >> 32) & 0x0FFFFFFFF ); // NA
  
  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  Nhit5inch = (unsigned int)( (L>>59) & 0x07 ); // NA
  NhitOD = (unsigned int)( (L>>51) & 0x0FF );   // NA
  NhitID = (unsigned int)( (L>>40) & 0x07FF );  // NA
  EventStatus = (int)( (L>>36) & 0x0F );
  //  EventStatus = (int)( (L >> 40) & 0x0F );
  unsigned long long int HigherTriggerType = (unsigned int)( (L >> 32) & 0x0F );  TriggerType = ( (HigherTriggerType << 32) | (L & 0x0FFFFFFFF) );

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  Float_t X[4];
  X[0] = (float)( (int)((L >> 53) & 0x07FF) - 1024);
  X[1] = (float)( (int)((L >> 42) & 0x07FF) - 1024);
  X[2] = (float)( (int)((L >> 31) & 0x07FF) - 1024);
  X[3] = 0;

  TotalChargeID = (float)( L & 0x07FFFFFFF )/10.0;

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  Float_t dX[4];
  Badness   = (unsigned int)( (L >> 36) & 0x0FFFFFFF );
  dX[0] = (float)((int)((L >> 24) & 0x0FFF) - 2048)/2048.0;
  dX[1] = (float)((int)((L >> 12) & 0x0FFF) - 2048)/2048.0;
  dX[2] = (float)((int)(   L      & 0x0FFF) - 2048)/2048.0;
  dX[3] = 0;

  Restore(&L, fBuffer, offset);
  offset += sizeof(L);
  TotalCharge5inch = (float)( (L >> 32) & 0x0FFFFFFFF )/10.0; // NA
  TotalChargeOD = (float)( L & 0x0FFFFFFFF )/10.0; // NA

  // FIXME: is this it??
  evtptr->fEventHeader.fRunNumber = RunNumber;
  evtptr->fEventHeader.fEventNumber = EventNumber;
  evtptr->fEventHeader.fTimeStamp = Double_t(TimeStamp);
  evtptr->fEventHeader.fTriggerType = TriggerType;
  evtptr->fEventHeader.fStatus = EventStatus;

  TKLTrack *track = evtptr->GimmeTrack("vector_track");
  Double_t vpm = X[0]*dX[0] + X[1]*dX[1] + X[2]*dX[2];
  Double_t norm = -2*vpm;
  for(Int_t i = 0; i < 4; i++) {
    track->fEntrance[i] = 10.*X[i]; // cm -> mm
    track->fExit[i] = 10.*(X[i] + norm*dX[i]);
  }
  track->fStatus = 0; // means valid track
  track->fReconStatus = Int_t(Badness); // (only 28bits used)
  track->fEnergy = 0.458 * TotalChargeID; // ARBITRARY Conversion, to match AKAT Units!

  return kHasEventData;
}

unsigned long long int TKLugReaderVF::Swap(unsigned long long int value)
{
  unsigned long long int swaped;
  unsigned char* p = (unsigned char*)(&swaped);
  unsigned char* org = (unsigned char*)(&value);

  for(int i=0; i<(int)sizeof(value); i++){
    p[i] = org[sizeof(value) - i -1];
  }
  return swaped;
}

 void TKLugReaderVF::Restore(unsigned long long int* L, 
			    const char* buf, int whence) 
{
  memcpy( (void*)L, (const void*)&(buf[whence]), sizeof((*L)) );
  // FIXME: test if swapping is needed
  *L = Swap(*L);
}

 Int_t TKLugReaderVF::ReadEventOrHistory(TKLEvent* evptr)
{
  Warning("ReadEventOrHistory", "Not Implemented");
  return 0;
}

 Bool_t TKLugReaderVF::ReadOneTrigger(TKLEventHeader* trigptr)
{
  Warning("ReadOneTrigger", "Not Implemented");
  return kFALSE;
}

 Bool_t TKLugReaderVF::ReadOneWaveform(TKLOneFEEChannel* fbeptr)
{
  Warning("ReadOneWaveform", "Not Implemented");
  return kFALSE;
}

 void TKLugReaderVF::Rewind()
{
  fFD->seekg(0, ios::beg);
}